# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild import kaitaistruct from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO from enum import Enum if getattr(kaitaistruct, 'API_VERSION', (0, 9)) < (0, 9): raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__)) class Output(KaitaiStruct): """This is an autogenerated file that contains definitions required for parsing the data of the YuanShen / Genshin Impact game. """ class BlossomShowType(Enum): blossom_showtype_none = 0 blossom_showtype_challenge = 1 blossom_showtype_npctalk = 2 blossom_showtype_groupchallenge = 3 class ActorType(Enum): invalid = 0 base_entity = 1 npc_actor = 2 quest_actor = 3 global_actor = 4 gadget_actor = 5 sub_global_actor = 6 cutscene_actor = 7 interaction_actor = 8 npcglobal_actor = 9 class MpPlayShowType(Enum): mp_play_show_normal = 0 mp_play_show_no_resin = 1 mp_play_show_two_material = 2 class SortModifierType(Enum): none = 0 priority = 1 durability_asc = 2 durability_des = 3 all = 4 class CookMethodType(Enum): cook_method_none = 0 cook_method_steam = 1 cook_method_boil = 2 cook_method_fry = 3 cook_method_bake = 4 class GroupKillPolicy(Enum): group_kill_none = 0 group_kill_all = 1 group_kill_monster = 2 group_kill_gadget = 3 group_kill_npc = 4 class ChestShowMoment(Enum): none = 0 on_create = 1 on_unlock = 2 class CodexQuestTextType(Enum): chapter_title = 1 chapter_num = 2 main_quest_title = 3 main_quest_desp = 4 sub_quest_title = 5 ip_customized_whole = 6 ip_customized_partial = 7 dialog_normal = 8 dialog_branch = 9 speaker_known = 10 speaker_unknown = 11 speaker_player = 12 aside = 13 narratage = 14 class EquipInSlotType(Enum): none = 0 take = 1 put = 2 class PushTipsCodexType(Enum): codex_none = 0 codex_element = 1 codex_enemy = 2 codex_system = 3 codex_adventure = 4 codex_unrecorded = 999 class MultistageStageType(Enum): multistage_stage_mechanicus_build = 0 multistage_stage_mechanicus_kill = 1 multistage_stage_mechanicus_flip_card = 2 multistage_stage_idle = 3 multistage_stage_fleur_fair_gallery = 4 multistage_stage_fleur_fair_boss = 5 multistage_stage_fleur_fair_preview = 6 multistage_stage_chess_build = 7 multistage_stage_chess_kill = 8 multistage_stage_irodori_chess_build = 9 multistage_stage_irodori_chess_kill = 10 class StandDirection(Enum): left = 0 front = 1 right = 2 class GalleryProgressScoreUiType(Enum): gallery_progress_score_ui_type_none = 0 gallery_progress_score_ui_type_buoyant_combat = 1 gallery_progress_score_ui_type_sumo_stage = 2 gallery_progress_score_ui_type_dig = 3 gallery_progress_score_ui_type_crystal_link = 4 class BlossomRefreshType(Enum): blossom_refresh_none = 0 blossom_refresh_scoin = 1 blossom_refresh_weapon = 2 blossom_refresh_exp = 3 blossom_refresh_crystal = 4 blossom_refresh_infused_crystal = 5 blossom_refresh_dragon_spine_a = 6 blossom_refresh_dragon_spine_b = 7 blossom_island_sentry_tower_a = 8 blossom_island_sentry_tower_b = 9 blossom_island_bomb = 10 blossom_refresh_blitz_rush_a = 11 blossom_refresh_blitz_rush_b = 12 class WeaponEnhanceRuleType(Enum): weapon_enhance_type_enable = 0 weapon_enhance_type_disabled = 1 class UgcTimeControlType(Enum): level = 0 challenge = 1 default = 2 class MarkOrder(Enum): none = 0 local_player = 1 other_player = 2 quest_main = 3 quest_branch = 4 radar = 5 transport_goddess = 6 dungeon = 7 quest_event = 8 quest_activity = 9 quest_world = 10 quest_random = 11 ore = 12 activity = 13 custom = 14 monster = 15 transport_other = 16 npc_adventure = 17 npc_activity = 18 area = 19 default = 20 npc_other = 21 vehicle = 22 quest_acception = 23 homeworld_main_house = 1001 homeworld_farm_field = 1002 homeworld_furniture_suite = 1003 homeworld_djinn = 1004 homeworld_npc = 1005 homeworld_trans_point = 1006 homeworld_safe_point = 1007 class QuestState(Enum): quest_state_none = 0 quest_state_unstarted = 1 quest_state_unfinished = 2 quest_state_finished = 3 quest_state_failed = 4 class HuntingCluePointType(Enum): hunting_clue_iteract = 0 hunting_clue_monster = 1 hunting_clue_gather = 2 hunting_clue_final = 3 class QuestExecType(Enum): quest_exec_none = 0 quest_exec_del_pack_item = 1 quest_exec_unlock_point = 2 quest_exec_unlock_area = 3 quest_exec_unlock_force = 4 quest_exec_lock_force = 5 quest_exec_change_avatar_elemet = 6 quest_exec_refresh_group_monster = 7 quest_exec_set_is_flyable = 8 quest_exec_set_is_weather_locked = 9 quest_exec_set_is_game_time_locked = 10 quest_exec_set_is_transferable = 11 quest_exec_grant_trial_avatar = 12 quest_exec_open_bored = 13 quest_exec_rollback_quest = 14 quest_exec_notify_group_lua = 15 quest_exec_set_open_state = 16 quest_exec_lock_point = 17 quest_exec_del_pack_item_batch = 18 quest_exec_refresh_group_suite = 19 quest_exec_remove_trial_avatar = 20 quest_exec_set_game_time = 21 quest_exec_set_weather_gadget = 22 quest_exec_add_quest_progress = 23 quest_exec_notify_daily_task = 24 quest_exec_create_pattern_group = 25 quest_exec_remove_pattern_group = 26 quest_exec_refresh_group_suite_random = 27 quest_exec_active_item_giving = 28 quest_exec_del_all_specific_pack_item = 29 quest_exec_rollback_parent_quest = 30 quest_exec_lock_avatar_team = 31 quest_exec_unlock_avatar_team = 32 quest_exec_update_parent_quest_reward_index = 33 quest_exec_set_daily_task_var = 34 quest_exec_inc_daily_task_var = 35 quest_exec_dec_daily_task_var = 36 quest_exec_active_activity_cond_state = 37 quest_exec_inactive_activity_cond_state = 38 quest_exec_add_cur_avatar_energy = 39 quest_exec_start_bargain = 41 quest_exec_stop_bargain = 42 quest_exec_set_quest_global_var = 43 quest_exec_inc_quest_global_var = 44 quest_exec_dec_quest_global_var = 45 quest_exec_register_dynamic_group = 46 quest_exec_unregister_dynamic_group = 47 quest_exec_set_quest_var = 48 quest_exec_inc_quest_var = 49 quest_exec_dec_quest_var = 50 quest_exec_random_quest_var = 51 quest_exec_activate_scanning_pic = 52 quest_exec_reload_scene_tag = 53 quest_exec_register_dynamic_group_only = 54 quest_exec_change_skill_depot = 55 quest_exec_add_scene_tag = 56 quest_exec_del_scene_tag = 57 quest_exec_init_time_var = 58 quest_exec_clear_time_var = 59 quest_exec_modify_climate_area = 60 quest_exec_grant_trial_avatar_and_lock_team = 61 quest_exec_change_map_area_state = 62 quest_exec_deactive_item_giving = 63 quest_exec_change_scene_level_tag = 64 quest_exec_unlock_player_world_scene = 65 quest_exec_lock_player_world_scene = 66 quest_exec_fail_maincoop = 67 quest_exec_modify_weather_area = 68 quest_exec_grant_trial_avatar_batch_and_lock_team = 69 class EntityTokenActionType(Enum): entity_token_action_type_invalid = -1 entity_token_action_type_fire_effect = 0 entity_token_action_type_attach_effect = 1 entity_token_action_type_apply_modifier = 2 entity_token_action_type_apply_level_modifier = 3 entity_token_action_type_audio = 4 entity_token_action_type_trigger_attack_event = 5 entity_token_action_type_send_effect_trigger = 6 entity_token_action_type_internal_fire_effect_god = 7 entity_token_action_type_internal_fire_effect_normal = 8 entity_token_action_type_internal_fire_effect_low = 9 entity_token_action_type_internal_attach_effect_god = 10 entity_token_action_type_internal_attach_effect_normal = 11 entity_token_action_type_internal_attach_effect_low = 12 entity_token_action_type_create_entity_sync = 13 entity_token_action_type_create_entity_async = 14 entity_token_action_type_ui_spawn = 15 entity_token_action_type_count = 16 class ConfigWeatherType(Enum): clear_sky = 0 cloudy = 1 foggy = 2 rain = 3 snow = 4 storm = 5 skill = 6 class CondfigAiRangeType(Enum): range_default = 0 range_xz_y = 1 class TowerBuffLastingType(Enum): tower_buff_lasting_none = 0 tower_buff_lasting_floor = 1 tower_buff_lasting_immediate = 2 tower_buff_lasting_level = 3 class DraftExecSubType(Enum): draft_exec_sub_none = 0 draft_exec_sub_island_party = 1 class SteerAttackTargetType(Enum): attack_target = 0 awake_target = 1 buddy_target = 2 class DailyTaskType(Enum): daily_task_quest = 0 daily_task_scene = 1 class OrderingType(Enum): less = 0 equal = 1 greater = 2 less_or_equal = 3 greater_or_equal = 4 class DungeonRosterCycleType(Enum): dungeon_roster_cycle_type_none = 0 dungeon_roster_cycle_type_by_order = 1 class ExpeditionOpenCondType(Enum): exp_open_cond_level = 0 exp_open_cond_point = 1 exp_open_cond_quest = 2 class ActivityMichiaeInteractType(Enum): activity_michiae_interact_none = 0 activity_michiae_interact_statue = 1 activity_michiae_interact_dark_challenge = 2 activity_michiae_interact_boss_challenge = 3 activity_michiae_interact_statue_show_reminder = 4 class GrowCurveType(Enum): grow_curve_none = 0 grow_curve_hp = 1 grow_curve_attack = 2 grow_curve_stamina = 3 grow_curve_strike = 4 grow_curve_anti_strike = 5 grow_curve_anti_strike1 = 6 grow_curve_anti_strike2 = 7 grow_curve_anti_strike3 = 8 grow_curve_strike_hurt = 9 grow_curve_element = 10 grow_curve_kill_exp = 11 grow_curve_defense = 12 grow_curve_attack_bomb = 13 grow_curve_hp_littlemonster = 14 grow_curve_element_mastery = 15 grow_curve_progression = 16 grow_curve_defending = 17 grow_curve_mhp = 18 grow_curve_matk = 19 grow_curve_toweratk = 20 grow_curve_hp_s5 = 21 grow_curve_hp_s4 = 22 grow_curve_hp_2 = 23 grow_curve_attack_2 = 24 grow_curve_attack_s5 = 31 grow_curve_attack_s4 = 32 grow_curve_attack_s3 = 33 grow_curve_strike_s5 = 34 grow_curve_defense_s5 = 41 grow_curve_defense_s4 = 42 grow_curve_attack_101 = 1101 grow_curve_attack_102 = 1102 grow_curve_attack_103 = 1103 grow_curve_attack_104 = 1104 grow_curve_attack_105 = 1105 grow_curve_attack_201 = 1201 grow_curve_attack_202 = 1202 grow_curve_attack_203 = 1203 grow_curve_attack_204 = 1204 grow_curve_attack_205 = 1205 grow_curve_attack_301 = 1301 grow_curve_attack_302 = 1302 grow_curve_attack_303 = 1303 grow_curve_attack_304 = 1304 grow_curve_attack_305 = 1305 grow_curve_critical_101 = 2101 grow_curve_critical_102 = 2102 grow_curve_critical_103 = 2103 grow_curve_critical_104 = 2104 grow_curve_critical_105 = 2105 grow_curve_critical_201 = 2201 grow_curve_critical_202 = 2202 grow_curve_critical_203 = 2203 grow_curve_critical_204 = 2204 grow_curve_critical_205 = 2205 grow_curve_critical_301 = 2301 grow_curve_critical_302 = 2302 grow_curve_critical_303 = 2303 grow_curve_critical_304 = 2304 grow_curve_critical_305 = 2305 class BattlePassMissionRefreshType(Enum): battle_pass_mission_refresh_daily = 0 battle_pass_mission_refresh_cycle = 1 battle_pass_mission_refresh_schedule = 2 battle_pass_mission_refresh_cycle_cross_schedule = 3 class TextLanguageType(Enum): language_none = 0 language_en = 1 language_sc = 2 language_tc = 3 language_fr = 4 language_de = 5 language_es = 6 language_pt = 7 language_ru = 8 language_jp = 9 language_kr = 10 language_th = 11 language_vn = 12 language_id = 13 language_tr = 14 language_it = 15 class ChannellerSlabBuffQuality(Enum): channeller_slab_buff_quality_none = 0 channeller_slab_buff_quality_green = 1 channeller_slab_buff_quality_blue = 2 channeller_slab_buff_quality_purple = 3 channeller_slab_buff_quality_orange = 4 class MechanicusCardTargetType(Enum): mechanicus_card_target_none = 0 mechanicus_card_target_all = 1 mechanicus_card_target_gadgets = 2 class ConfigLevelPolygonTag(Enum): plain = 0 forest = 1 hill = 2 water = 3 mountain = 4 class MaterialCodexType(Enum): codex_collection = 0 codex_cooking_food = 1 codex_war_trophies = 2 codex_widget = 3 class ReminderShowType(Enum): none = 0 talk = 1 bubble = 2 class IrodoriPoetryEntityType(Enum): irodori_poetry_entity_type_none = 0 irodori_poetry_entity_type_empty_gadget = 1 irodori_poetry_entity_type_gather = 2 irodori_poetry_entity_type_monster = 3 class HandbookQuestGuideShowCondType(Enum): quest_guide_show_cond_none = 0 quest_guide_show_cond_area_unlocked = 1 quest_guide_show_cond_prequest_finished = 2 quest_guide_show_cond_level_gt_or_eq = 3 class ForgeUnlockMethod(Enum): forge_unlock_none = 0 forge_unlock_quest = 1 forge_unlock_formula = 2 class VelocityForceType(Enum): retreat_type = 0 retreat_air_type = 1 rush_move_type = 2 wind_zone_type = 3 airflow_type = 4 rise_type = 5 speedup_type = 6 airflow_acc_type = 7 inertia_type = 8 fixed_rush_move_type = 9 light_core_type_normal = 10 light_core_type_accelerate = 11 gorou_zone_type = 12 ugc_directed_force_type = 13 class RotType(Enum): rot_none = 0 rot_angle = 1 rot_round = 2 class EmoBackType(Enum): none = 0 without_blink = 1 with_blink = 2 class RecipeType(Enum): recipe_type_none = 0 recipe_type_combine = 1 recipe_type_convert = 2 recipe_type_combine_homeworld = 3 class AbilityTargetting(Enum): self = 0 caster = 1 target = 2 self_attack_target = 3 other = 4 applier = 5 owner = 6 cur_team_avatars = 7 cur_local_avatar = 8 origin_owner = 9 team = 10 target_owner = 11 target_origin_owner = 12 all_player_avatars = 13 all_teams = 14 remote_teams = 15 target_team = 16 caster_owner = 17 caster_origin_owner = 18 mp_level = 19 vehicle = 20 class RoguelikeShikigamiUnlockType(Enum): shikigami_unlock_none = 0 shikigami_unlock_shikigami = 1 shikigami_unlock_activity_day = 2 shikigami_unlock_roguelike_stage = 3 class DragonSpinePhase(Enum): dragon_spine_phase_none = 0 dragon_spine_phase_first = 1 dragon_spine_phase_second = 2 dragon_spine_phase_third = 3 dragon_spine_phase_fourth = 4 class WorldAreaLevelupActionType(Enum): world_area_action_none = 0 world_area_action_reward = 1 world_area_action_improve_stamina = 2 world_area_action_unlock_force = 3 world_area_action_unlock_dungeon_entrance = 4 world_area_action_activate_item = 5 world_area_action_unlock_dynamic_hard = 6 world_area_action_unlock_air_portal = 7 world_area_action_notify_group = 8 class WeatherType(Enum): clear_sky = 0 cloudy = 1 foggy = 2 rain = 3 snow = 4 storm = 5 class VisionLevelType(Enum): vision_level_normal = 0 vision_level_little_remote = 1 vision_level_remote = 2 vision_level_super = 3 vision_level_nearby = 4 vision_level_super_nearby = 5 vision_level_num = 6 class TweenEaseType(Enum): ease_in_quad = 0 ease_out_quad = 1 ease_in_out_quad = 2 ease_in_cubic = 3 ease_out_cubic = 4 ease_in_out_cubic = 5 ease_in_quart = 6 ease_out_quart = 7 ease_in_out_quart = 8 ease_in_quint = 9 ease_out_quint = 10 ease_in_out_quint = 11 ease_in_sine = 12 ease_out_sine = 13 ease_in_out_sine = 14 ease_in_expo = 15 ease_out_expo = 16 ease_in_out_expo = 17 ease_in_circ = 18 ease_out_circ = 19 ease_in_out_circ = 20 linear = 21 spring = 22 ease_in_bounce = 23 ease_out_bounce = 24 ease_in_out_bounce = 25 ease_in_back = 26 ease_out_back = 27 ease_in_out_back = 28 ease_in_elastic = 29 ease_out_elastic = 30 ease_in_out_elastic = 31 class PsActivitiesCategoryType(Enum): progress = 0 open_ended = 1 competitive = 2 challenge = 3 class ElementReactionType(Enum): none = 0 explode = 1 stream = 2 burning = 3 burned = 4 wet = 5 overgrow = 6 melt = 7 freeze = 8 anti_fire = 9 rock = 10 slow_down = 11 shock = 12 wind = 13 electric = 14 fire = 15 superconductor = 16 swirl_fire = 17 swirl_water = 18 swirl_electric = 19 swirl_ice = 20 swirl_fire_accu = 21 swirl_water_accu = 22 swirl_electric_accu = 23 swirl_ice_accu = 24 stick_rock = 25 stick_water = 26 crystallize_fire = 27 crystallize_water = 28 crystallize_electric = 29 crystallize_ice = 30 frozen_broken = 31 stick_grass = 32 overdose = 33 class SceneSurfaceType(Enum): invalid = 0 grass = 1 dirt = 2 rock = 3 snow = 4 water = 5 tile = 6 sand = 7 wood = 8 iron = 9 tree = 10 ice = 11 marble = 12 carpet = 13 wood_log = 14 cloud = 15 coin = 16 snow_rock = 17 electric_water = 18 sakura = 19 black_mud = 20 transparent_brick = 21 class AbilityEntityVisibleReason(Enum): default = 0 gallary = 1 class GuestButtonShowType(Enum): hide = 0 grap = 1 class PerfRatingCategory(Enum): cpu = 0 memory = 1 gpu_memory = 2 gpu = 3 general = 4 binary_default = 5 device_specific = 6 invalid = 7 class LanV2projectionRootPointMotionType(Enum): none = 0 free_rotation = 1 single_axis_rotation = 2 class OnEventType(Enum): none = 0 hp = 1 exp_gain = 2 chest_open = 3 quest_finish = 4 pick_item = 5 hp_up = 6 hp_down = 7 energy_donw_by_skill = 8 skill_ready = 9 class InteractionType(Enum): none = 0 dialog = 1 dialog_next = 2 dialog_finish = 3 dialog_select = 4 body_lang = 5 steer_to = 6 look_at = 7 look_at_eyectrl = 8 camera_move = 9 sound = 10 cutscene = 11 shop_exchange = 12 gadget_touch = 13 emo_sync = 14 ui_trigger = 15 emotion = 16 visible = 17 lua_action = 18 black_screen = 19 goddess = 20 show_message = 21 camera_focus = 22 dialog_clear = 23 audio_play = 24 video_play = 25 camera_dof = 26 move_to = 27 request_msg = 28 camera_shake = 29 emoji_bubble = 30 time_protect = 31 simple_black_screen = 32 simple_ui_show = 33 open_blossom_mark = 34 speech_bubble = 35 emotion_template = 36 sit_or_stand = 37 play_effect = 38 teleport_to = 39 first_sight = 40 set_animator = 41 play_post_effect = 42 play_frame_face_animation = 43 hide_widget_pet = 44 local_gadget_op = 45 play_ui_effect = 46 set_player_npc_energy_type = 47 change_npc_mat = 48 special_element_view = 49 ban_self_global_value = 50 set_model_transform = 51 camera_spline = 52 spawn_attach = 53 change_time = 54 close_gpu_culling = 55 other = 56 class ConfigScheduleJobType(Enum): default = 0 lose = 1 class TalkExecType(Enum): talk_exec_none = 0 talk_exec_set_gadget_state = 1 talk_exec_set_game_time = 2 talk_exec_notify_group_lua = 3 talk_exec_set_daily_task_var = 4 talk_exec_inc_daily_task_var = 5 talk_exec_dec_daily_task_var = 6 talk_exec_set_quest_var = 7 talk_exec_inc_quest_var = 8 talk_exec_dec_quest_var = 9 talk_exec_set_quest_global_var = 10 talk_exec_inc_quest_global_var = 11 talk_exec_dec_quest_global_var = 12 talk_exec_trans_scene_dummy_point = 13 class OrnamentsType(Enum): none = 0 fly = 1 class LuaTaskType(Enum): normal = 0 move = 1 threat = 2 free_style = 3 limit_region = 4 btn_trans = 5 steer = 6 speech_bubble = 7 force_walk = 8 home = 9 safe_circle = 10 npc_follow_player = 11 class MaterialDestroyType(Enum): destroy_none = 0 destroy_return_material = 1 class FurnitureDeploySurfaceType(Enum): ground = 0 wall = 1 ceil = 2 stack_obj_plane = 3 door = 4 chandelier = 5 floor = 6 wall_body = 7 carpet = 8 lego_rockery = 9 stair = 10 npc = 11 animal = 12 apartment = 13 furniture_suite = 14 road = 15 terrain = 16 class MarkIconType(Enum): default = 0 mark_church = 1 mark_knights = 2 mark_pub = 3 mark_souvenir = 4 mark_restaurant = 5 mark_general_cargo = 6 mark_blacksmith = 7 mark_team_arranger = 8 mark_daily_task = 9 mark_random_task = 10 mark_adventurers = 11 mark_alchemy = 12 mark_sea_lamp_giving = 13 mark_investigation_monster = 14 mark_blacksmith_liyue = 15 mark_souvenir_liyue = 16 mark_restaurant_liyue = 17 mark_reputation = 18 mark_reputation_liyue = 19 mark_reputation_inazuma = 20 mark_blacksmith_inazuma = 21 mark_souvenir_inazuma = 22 mark_restaurant_inazuma = 23 mark_group_link = 24 mark_fish = 25 mark_fish_liyue = 26 mark_fish_inazuma = 27 mark_group_link_area = 28 mark_trans_point = 100 mark_trans_point_locked = 101 mark_portal = 102 mark_dungeon_entry = 103 mark_dungeon_entry_locked = 104 mark_weekly_dungeon_entry = 105 mark_weekly_dungeon_entry_locked = 106 mark_daily_dungeon_entry = 107 mark_daily_dungeon_entry_locked = 108 mark_tower_dungeon_entry = 109 mark_tower_dungeon_entry_locked = 110 mark_daily_dungeon_entry_to_be_explored = 111 mark_tower_dungeon_entry_to_be_explored = 112 mark_effigy_dungeon_entry = 113 mark_effigy_dungeon_entry_locked = 114 mark_fleur_fair_dungeon_entry = 115 mark_blitz_rush_dungeon_entry = 116 mark_hachi_dungeon_entry = 117 mark_mini_eldritch_dungeon_entry = 118 mark_goddess_locked = 199 mark_goddess_unlocked = 204 mark_packet_anchor = 205 mark_quest = 300 mark_dangerous_quest = 301 mark_quest_area = 302 mark_dangerous_quest_area = 303 mark_custom = 400 mark_custom_boss = 402 mark_custom_box = 403 mark_custom_collect = 404 mark_custom_cooking = 405 mark_custom_main_task = 407 mark_custom_monster = 408 mark_custom_slime = 411 mark_custom_trap = 412 mark_custom_wind = 413 mark_custom_fish = 414 mark_local_avatar = 500 mark_player1 = 501 mark_player2 = 502 mark_player3 = 503 mark_player4 = 504 mark_bored_monster = 505 mark_radar_hint = 506 mark_activity = 507 mark_talk = 508 mark_miscs_marvs = 509 mark_activity_aster_little = 510 mark_activity_aster_middle = 511 mark_radar_hint_area = 512 mark_activity_asterlarge = 513 mark_hunting_area = 514 mark_activity_aster_middle_npc = 515 mark_widget_sever_detector_area = 516 mark_activity_flight_challenge_point = 517 mark_elder_tree = 518 mark_elder_tree_event = 519 mark_widget_treasure_map_area = 520 mark_activity_treasure_map_npc = 521 mark_activity_dragon_spine_boss = 522 mark_activity_blessing = 523 mark_activity_monster_banner_drake_primo_rock = 524 mark_activity_expedition_challenge_area = 525 mark_mechanicis_npc = 526 mark_activity_water_sprite_explore_area = 527 mark_activity_arena_challenge = 528 mark_activity_fleur_fair_fall = 529 mark_activity_fleur_fair_balloon = 530 mark_activity_water_sprite_boss = 531 mark_activity_summer_time_race = 532 mark_activity_region_search = 600 mark_gallery_challenge = 601 mark_activity_fleur_fair_npc = 602 mark_channeller_slab_camp_low = 603 mark_channeller_slab_camp_middle = 604 mark_channeller_slab_camp_high = 605 mark_channeller_slab_one_off_dungeon = 606 mark_channeller_slab_loop_dungeon = 607 mark_channeller_slab_npc = 608 mark_activity_mini_tomo_hili_wei_area = 609 mark_activity_hide_and_seek_npc = 610 mark_homeworld_djinn = 611 mark_homeworld_djinn_weekend = 612 mark_homeworld_main_house = 613 mark_hide_and_seek_hunter = 614 mark_activity_buoyant_combat_point = 615 mark_activity_bounce_conjuring = 616 mark_homeworld_npc = 617 mark_summer_isle_signal_point = 620 mark_vehicle_summon_point = 621 mark_vehicle_summon_point_locked = 622 mark_bounce_conjuring_npc = 625 mark_vehicle_skiff = 626 mark_homeworld_furniture_suite = 630 mark_homeworld_trans_point = 631 mark_homeworld_safe_point = 632 mark_homeworld_farm_field1 = 633 mark_homeworld_farm_field2 = 634 mark_homeworld_farm_field3 = 635 mark_activity_treasure_map_challenge = 700 mark_activity_blitz_rush_parkour = 701 mark_activity_perpetual_npc = 705 mark_oraionokami_tree = 710 mark_sumo_dungeon = 711 mark_moonfin_trial_challenge = 712 mark_moonfin_trial_final = 713 mark_luna_rite_explore_area = 720 mark_luna_rite_npc = 721 mark_luna_rite_crystal = 722 mark_luna_rite_chest = 723 mark_roguelike = 730 mark_bugyowu = 800 mark_chashitsu = 801 mark_homeworld_paimon = 802 mark_music_game_npc = 803 mark_grow_flowers_npc = 804 mark_hachi_stealth_challenge = 805 mark_hachi_battle_challenge = 806 mark_winter_camp_snowman = 810 mark_activity_winter_camp_boss = 811 mark_animal_capture_shop = 820 mark_alcor_transmit = 821 mark_qunyuge_transmit = 822 mark_ashanpo_npc = 830 mark_potion_dungeon_entry = 840 mark_projection_game_entry = 850 mark_lantern_rite_ship_summon_point = 860 mark_lantern_rite_ship_summon_point_locked = 861 mark_michiae_offering = 870 mark_bartender_npc = 871 mark_michiae_chest = 872 mark_michiae_challenge = 873 mark_custom_level = 874 mark_luminance_stone_npc = 2601 mark_crystal_link = 2602 mark_quest_acception = 2603 mark_irodori_flower_npc = 2610 mark_irodori_photo_npc = 2611 mark_irodori_master_npc = 2612 mark_irodori_chess_npc = 2613 mark_music_game_v3npc = 2701 mark_activity_gacha_npc = 2702 mark_rogue_diary = 2703 mark_cocoon_space = 2704 mark_island_party_npc = 2801 mark_summer_time_v2wanye_dungeon_entry = 2802 mark_summer_time_v2xinyan_dungeon_entry = 2803 mark_summer_time_v2feixieer_dungeon_entry = 2804 mark_summer_time_v2mona_dungeon_entry = 2805 mark_summer_time_v2boat_summon_point = 2806 mark_gear_game_entry = 2807 mark_echo_shell_v2 = 2808 mark_arena_challenge_v3 = 2809 class QteStepButtonStyleType(Enum): qte_step_button_style_normal = 0 qte_step_button_style_single = 1 qte_step_button_style_direct = 2 class SignInCondType(Enum): sign_in_cond_none = 0 sign_in_cond_player_level = 1 sign_in_cond_finish_quest = 2 sign_in_cond_finish_parent_quest = 3 sign_in_cond_average_avatar_level = 4 sign_in_cond_max_avatar_level = 5 sign_in_cond_avatar_num = 6 class HomeAvatarEventType(Enum): home_avatar_event_none = 0 home_avatar_reward_event = 1 home_avatar_summon_event = 2 class MonsterSizeType(Enum): normal_humanoid_type = 0 stoop_type = 1 strong_humanoid_type = 2 slime_type = 3 other_type = 99 class WatcherTriggerTraceBackType(Enum): watcher_trace_back_none = 0 watcher_trace_back_yes = 1 watcher_trace_back_no = 2 class IrodoriChessCardTargetType(Enum): irodori_chess_card_target_default = 0 irodori_chess_card_target_all = 1 irodori_chess_card_target_gadgets = 2 class EntityColliderType(Enum): move_collider = 0 scene_prop_collider = 1 class MonitorType(Enum): monitor_never = 0 monitor_off_stage = 1 monitor_on_stage = 2 monitor_always = 3 class IrodoriChessCardNumericalModificationMode(Enum): irodori_card_numerical_default_mode = 0 irodori_card_numerical_base = 1 irodori_card_numerical_percentage = 2 class GuideOperator(Enum): equal = 0 greater = 1 less = 2 greater_equal = 3 less_equal = 4 class AnimeGroupType(Enum): none = 0 bartender = 1 count = 2 class DamageAttacker(Enum): caster = 0 self = 1 class InvestigationMonsterMapMarkCreateType(Enum): after_unlock = 0 nerver_create = 1 extra_conditions = 2 class BlossomRefreshCondType(Enum): blossom_refresh_cond_none = 0 blossom_refresh_cond_player_level_equal_greater = 1 blossom_refresh_cond_player_level_less_than = 2 blossom_refresh_cond_open_state = 3 blossom_refresh_cond_quest_finish = 4 blossom_refresh_cond_activity_cond = 5 blossom_refresh_cond_scene_tag_added = 6 class ServerMessageShowType(Enum): server_message_show_type_none = 0 server_message_show_type_message = 1 server_message_show_type_info_message = 2 class OpenStateType(Enum): open_state_none = 0 open_state_paimon = 1 open_state_paimon_navigation = 2 open_state_avatar_promote = 3 open_state_avatar_talent = 4 open_state_weapon_promote = 5 open_state_weapon_awaken = 6 open_state_quest_remind = 7 open_state_game_guide = 8 open_state_cook = 9 open_state_weapon_upgrade = 10 open_state_reliquary_upgrade = 11 open_state_reliquary_promote = 12 open_state_weapon_promote_guide = 13 open_state_weapon_change_guide = 14 open_state_player_lvup_guide = 15 open_state_freshman_guide = 16 open_state_skip_freshman_guide = 17 open_state_guide_move_camera = 18 open_state_guide_scale_camera = 19 open_state_guide_keyboard = 20 open_state_guide_move = 21 open_state_guide_jump = 22 open_state_guide_sprint = 23 open_state_guide_map = 24 open_state_guide_attack = 25 open_state_guide_fly = 26 open_state_guide_talent = 27 open_state_guide_relic = 28 open_state_guide_relic_prom = 29 open_state_combine = 30 open_state_gacha = 31 open_state_guide_gacha = 32 open_state_guide_team = 33 open_state_guide_proud = 34 open_state_guide_avatar_promote = 35 open_state_guide_adventure_card = 36 open_state_forge = 37 open_state_guide_bag = 38 open_state_expedition = 39 open_state_guide_adventure_dailytask = 40 open_state_guide_adventure_dungeon = 41 open_state_tower = 42 open_state_world_stamina = 43 open_state_tower_first_enter = 44 open_state_resin = 45 open_state_limit_region_freshmeat = 47 open_state_limit_region_global = 48 open_state_multiplayer = 49 open_state_guide_mousepc = 50 open_state_guide_multiplayer = 51 open_state_guide_dungeonreward = 52 open_state_guide_blossom = 53 open_state_avatar_fashion = 54 open_state_photograph = 55 open_state_guide_kslquest = 56 open_state_personal_line = 57 open_state_guide_personal_line = 58 open_state_guide_appearance = 59 open_state_guide_process = 60 open_state_guide_personal_line_key = 61 open_state_guide_widget = 62 open_state_guide_activity_skill_aster = 63 open_state_guide_coldclimate = 64 open_state_derivative_mall = 65 open_state_guide_exitmultiplayer = 66 open_state_guide_theatremachanicus_build = 67 open_state_guide_theatremachanicus_rebuild = 68 open_state_guide_theatremachanicus_card = 69 open_state_guide_theatremachanicus_monster = 70 open_state_guide_theatremachanicus_mission_check = 71 open_state_guide_theatremachanicus_build_select = 72 open_state_guide_theatremachanicus_challenge_start = 73 open_state_guide_convert = 74 open_state_guide_theatremachanicus_multiplayer = 75 open_state_guide_coop_task = 76 open_state_guide_homeworld_adeptiabode = 77 open_state_guide_homeworld_deploy = 78 open_state_guide_channellerslab_equip = 79 open_state_guide_channellerslab_mp_solution = 80 open_state_guide_channellerslab_power = 81 open_state_guide_hideandseek_skill = 82 open_state_guide_homeworld_maplist = 83 open_state_guide_relicresolve = 84 open_state_guide_gguide = 85 open_state_guide_gguide_hint = 86 open_state_guide_channellerslab_equip_v2 = 87 open_state_guide_channellerslab_mp_solution_v2 = 88 open_state_guide_channellerslab_power_v2 = 89 open_state_guide_quick_teammemberchange = 90 open_state_gguide_firstshow = 91 open_state_gguide_mainpage_entry_disappear = 92 open_state_city_repuation_mengde = 800 open_state_city_repuation_liyue = 801 open_state_city_repuation_ui_hint = 802 open_state_city_repuation_inazuma = 803 open_state_shop_type_mall = 900 open_state_shop_type_recommanded = 901 open_state_shop_type_genesiscrystal = 902 open_state_shop_type_giftpackage = 903 open_state_shop_type_paimon = 1001 open_state_shop_type_city = 1002 open_state_shop_type_blacksmith = 1003 open_state_shop_type_grocery = 1004 open_state_shop_type_food = 1005 open_state_shop_type_sea_lamp = 1006 open_state_shop_type_virtual_shop = 1007 open_state_shop_type_liyue_grocery = 1008 open_state_shop_type_liyue_souvenir = 1009 open_state_shop_type_liyue_restaurant = 1010 open_state_shop_type_inazuma_souvenir = 1011 open_state_shop_type_npc_tomoki = 1012 open_state_shop_type_inazuma_souvenir_black_bar = 1013 open_adventure_manual = 1100 open_adventure_manual_city_mengde = 1101 open_adventure_manual_city_liyue = 1102 open_adventure_manual_monster = 1103 open_adventure_manual_boss_dungeon = 1104 open_state_activity_sealamp = 1200 open_state_activity_sealamp_tab2 = 1201 open_state_activity_sealamp_tab3 = 1202 open_state_battle_pass = 1300 open_state_battle_pass_entry = 1301 open_state_activity_crucible = 1400 open_state_activity_newbeebouns_open = 1401 open_state_activity_newbeebouns_close = 1402 open_state_activity_entry_open = 1403 open_state_mengde_infusedcrystal = 1404 open_state_liyue_infusedcrystal = 1405 open_state_snow_mountain_elder_tree = 1406 open_state_miracle_ring = 1407 open_state_coop_line = 1408 open_state_inazuma_infusedcrystal = 1409 open_state_fish = 1410 open_state_guide_sumo_team_skill = 1411 open_state_guide_fish_recipe = 1412 open_state_home = 1500 open_state_activity_homeworld = 1501 open_state_adeptiabode = 1502 open_state_home_avatar = 1503 open_state_home_edit = 1504 open_state_home_edit_tips = 1505 open_state_reliquary_decompose = 1600 open_state_activity_h5 = 1700 open_state_oraionokami = 2000 open_state_guide_chess_mission_check = 2001 open_state_guide_chess_build = 2002 open_state_guide_chess_wind_tower_circle = 2003 open_state_guide_chess_card_select = 2004 open_state_inazuma_mainquest_finished = 2005 open_state_paimon_lvinfo = 2100 open_state_teleport_hud = 2101 open_state_guide_map_unlock = 2102 open_state_guide_paimon_lvinfo = 2103 open_state_guide_ambortransport = 2104 open_state_guide_fly_second = 2105 open_state_guide_kaeya_clue = 2106 open_state_capture_codex = 2107 open_state_activity_fish_open = 2200 open_state_activity_fish_close = 2201 open_state_guide_rogue_map = 2205 open_state_guide_rogue_rune = 2206 open_state_guide_bartender_formula = 2210 open_state_guide_bartender_mix = 2211 open_state_guide_bartender_cup = 2212 open_state_guide_mail_favorites = 2400 open_state_guide_potion_configure = 2401 open_state_guide_lanv2_firework = 2402 open_state_loadingtips_enkanomiya = 2403 open_state_michiae_casket = 2500 open_state_mail_collect_unlock_red_point = 2501 open_state_lumen_stone = 2600 open_state_guide_crystallink_buff = 2601 open_state_guide_music_game_v3 = 2700 open_state_guide_music_game_v3_real_time_edit = 2701 open_state_guide_music_game_v3_timeline_edit = 2702 open_state_guide_music_game_v3_setting = 2703 open_state_guide_robotgacha = 2704 open_state_guide_fragile_resin = 2800 open_adventure_manual_education = 2801 class MoveCategoryAi(Enum): land = 0 amphibious = 1 water = 2 air_land_amphibious = 3 air = 4 class JsonClimateType(Enum): normal = 0 cold = 1 hot = 2 cold_monster = 3 hot_monster = 4 sea_mist = 5 hero_course = 6 sea_mist_surrounding = 7 tatari_region = 8 trans_climate = 9 seirai_storm = 10 tsurumi_mist = 11 tsurumi_thunder = 12 tsurumi_regional_mist = 13 count = 14 class RegionSearchCondType(Enum): region_search_cond_none = 0 region_search_cond_activity_cond = 1 region_search_cond_finish_search = 2 class DialogType(Enum): lock_frame = 0 bubble = 1 narration = 2 other = 3 class AvatarIdentityType(Enum): avatar_identity_master = 0 avatar_identity_normal = 1 class SectrStreamObjectType(Enum): none = 0 terrain = 1 lod = 2 vo = 3 other = 4 terrain_grass = 5 water_tile = 6 navmesh = 7 occlusion = 8 particle = 9 fog_texture = 10 hlod = 11 limit_region = 12 vo_collider = 13 lod_collider = 14 reflection_prob_tile = 15 hlod_block = 16 class VodPlayerType(Enum): live = 0 class AiTargetSystemType(Enum): threat = 0 master = 1 servant = 2 owner = 3 children = 4 buddy = 5 nerve_target = 6 awake_target = 7 class MarkType(Enum): default = 0 trans_point = 1 quest = 2 custom = 3 local_avatar = 4 companion = 5 monster = 6 near_hint = 8 scene_point = 9 task = 10 boss = 11 talk = 12 packet_anchor = 13 widget = 14 flight_challenge = 15 hunting = 16 routine = 17 activity_search_region = 18 gallery_challenge = 19 homeworld_dynamic = 20 signal_point = 21 vehicle = 22 homeworld_furniture_suite = 23 activity = 24 homeworld_farm_field = 25 offering = 26 quest_acception = 27 class DungeonPlayType(Enum): dungeon_play_type_none = 0 dungeon_play_type_foggy_maze = 1 dungeon_play_type_trial_avatar = 2 dungeon_play_type_mist_trial = 3 class LoadingTipsSituationType(Enum): situation_type_none = 0 situation_type_common_transport = 1 situation_type_enter_quest_dungeon = 2 situation_type_enter_daily_dungeon = 3 situation_type_enter_tower = 4 situation_type_enter_room = 5 situation_type_login = 6 situation_type_logout = 7 situation_type_revive = 8 situation_type_enter_homeworld = 9 situation_type_enter_island = 10 class PlaceNameActionType(Enum): default = 0 open = 1 close = 2 class ConfigGuideContextListType(Enum): common = 0 class MixinTargetting(Enum): none = 0 allied = 1 enemy = 2 all = 3 class LimitRegionType(Enum): limit_region_type_none = 0 limit_region_type_bigworld = 1 limit_region_type_activity = 2 limit_region_type_homeworld = 3 class RegionSearchRecycleType(Enum): region_search_recycle_none = 0 region_search_recycle_progress = 1 class HideAndSeekSkillSubCategory(Enum): hide_and_seek_skill_sub_category_none = 0 hide_and_seek_skill_sub_category_common = 1 hide_and_seek_skill_sub_category_skill1 = 2 hide_and_seek_skill_sub_category_skill2 = 3 class GuideLevelType(Enum): all = 0 not_dungeon = 1 only_big_world = 2 class WidgetInfoPos(Enum): tl = 0 t = 1 tr = 2 l = 3 r = 4 bl = 5 b = 6 br = 7 class ActionPanelEffectSlot(Enum): element_art = 0 element_burst = 1 hp_bar = 2 class OpActivityTrackType(Enum): track_none = 0 track_by_city = 1 class TaaQuality(Enum): taa_low = 0 taa_high = 1 class EffectTargetType(Enum): effect_target_none = 0 effect_target_solo = 1 effect_target_team = 2 class HuntingOfferDifficultyType(Enum): hunting_difficulty_easy = 0 hunting_difficulty_medium = 1 hunting_difficulty_hard = 2 class TowerCondType(Enum): tower_cond_none = 0 tower_cond_finish_time_less_than = 1 tower_cond_left_hp_greater_than = 2 tower_cond_challenge_left_time_more_than = 3 class RadarHintType(Enum): default = 0 oculus = 1 ore = 2 harvet_gadget = 3 small_meteorite = 4 regin_feather_intact = 5 abyssalisle_harvest = 6 abyssalisle_plant = 7 echo_shell = 8 general = 1000 class GuideMultiPlayerMode(Enum): all = 0 host = 1 guest = 2 class QuestGuideStyle(Enum): quest_guide_style_none = 0 quest_guide_style_start = 1 quest_guide_style_target = 2 quest_guide_style_finish = 3 quest_guide_style_point = 4 class LanV2projectionMotionType(Enum): free_rotation = 0 single_axis_rotation = 1 single_axis_translation = 2 class BlessingScanType(Enum): blessing_scan_type_none = 0 blessing_scan_type_monster = 1 blessing_scan_type_gather = 2 class BodyType(Enum): body_none = 0 body_boy = 1 body_girl = 2 body_lady = 3 body_male = 4 body_loli = 5 class UiInteractType(Enum): ui_interact_type_normal = 0 class SumoDifficultyType(Enum): sumo_difficulty_easy = 0 sumo_difficulty_mid = 1 sumo_difficulty_hard = 2 class GraphicsSettingEntryType(Enum): invalid = 0 target_frame_rate = 1 render_resolution = 2 shadow_quality = 3 postprocess_effect = 4 particle_effect = 5 comprehensive_quality = 6 v_sync = 7 anti_aliasing = 8 volumetric_fog = 9 reflection = 10 motion_blur = 11 bloom = 12 crowd_density = 13 obsolete_online_effect = 14 screen_subsurface_scattering = 15 online_effect = 16 anisotropic_filtering = 17 volatile_setting = 18 class RandTaskType(Enum): rand_task_quest = 0 rand_task_scene = 1 class MatchSubType(Enum): match_sub_type_none = 0 match_sub_type_hide = 1 match_sub_type_bounce_conjuring = 2 match_sub_type_island_party = 3 class BitwiseOperator(Enum): and_ = 0 or_ = 1 not_ = 2 xor = 3 class ShopPrecondition(Enum): shop_precondition_none = 0 shop_precondition_specify = 1 shop_precondition_rest = 2 shop_precondition_sheet_rest = 3 shop_precondition_sheet_teasure_map_region = 4 shop_precondition_home_level = 5 shop_precondition_quest_finish = 6 shop_precondition_sheet_fleur_fair_watcher_finish = 7 shop_precondition_quest_finish_all = 8 shop_precondition_quest_finish_any = 9 class TalkLoadType(Enum): talk_normal_quest = 0 talk_blossom = 1 talk_activity = 2 talk_coop = 3 talk_gadget = 4 class TokenForceEnqueueReason(Enum): element_reaction = 0 ability_state = 1 class GuideCameraAction(Enum): move = 0 scale = 1 class ProgressShowType(Enum): progresstype_none = 0 progresstype_finish = 1 progresstype_thousand_to_one = 2 class QteStepButtonSlideDirectType(Enum): qte_step_button_slide_direct_up = 0 qte_step_button_slide_direct_down = 1 qte_step_button_slide_direct_left = 2 qte_step_button_slide_direct_right = 3 class AnimatorParamType2(Enum): trigger = 0 bool = 1 int = 2 float = 3 class CommonPlayerTipsType(Enum): common_player_tips_type_finish = 0 common_player_tips_type_start = 1 common_player_tips_type_fail = 2 class ChessCardQualityType(Enum): card_quality_noraml = 0 card_quality_good = 1 card_quality_percect = 2 class ActorEvtTargetType(Enum): single = 0 all = 1 class RogueGadgetStateType(Enum): rogue_gadget_state_none = 0 rogue_gadget_state_door_open = 1 rogue_gadget_state_door_close = 2 rogue_gadget_state_operator_default = 3 rogue_gadget_state_operator_in_challenge = 4 rogue_gadget_state_operator_finish_challenge = 5 rogue_gadget_state_operator_after_use = 6 rogue_gadget_state_operator_forbid = 7 class EntityAppearVisionType(Enum): vision_none = 0 vision_meet = 1 vision_reborn = 2 vision_replace = 3 vision_waypoint_reborn = 4 vision_miss = 5 vision_die = 6 vision_gather_escape = 7 vision_refresh = 8 vision_transport = 9 vision_replace_die = 10 class ConfigAiCombatPhase(Enum): default = 0 p1 = 1 p2 = 2 p3 = 3 p4 = 4 p5 = 5 class MusicStimulus(Enum): none = 0 stage_start = 1 stage_ready = 2 stage_finish = 4 quest_begin = 8 quest_end = 16 cutscene_begin = 32 cutscene_end = 64 cutscene_custom = 128 dialog_begin = 256 dialog_end = 512 combat_begin = 1024 combat_end = 2048 teleport_begin = 4096 teleport_end = 8192 area_change = 16384 death = 32768 weather_change = 65536 menu_open = 131072 menu_close = 262144 class ShopType(Enum): shop_type_none = 0 shop_type_recommend = 900 shop_type_hcoin = 901 shop_type_package = 902 shop_type_mcoin = 903 shop_type_paimon = 1001 shop_type_city = 1002 shop_type_blacksmith = 1003 shop_type_grocery = 1004 shop_type_food = 1005 shop_type_sea_lamp = 1006 shop_type_virtual_shop = 1007 shop_type_liyue_grocery = 1008 shop_type_liyue_souvenir = 1009 shop_type_liyue_restaurant = 1010 shop_type_npc_flora = 1011 shop_type_npc_charles = 1012 shop_type_npc_shiliu = 1013 shop_type_npc_schulz = 1014 shop_type_npc_brook = 1015 shop_type_npc_hopkins = 1016 shop_type_npc_draff = 1017 shop_type_npc_chloris = 1018 shop_type_npc_licai = 1019 shop_type_npc_yueshu = 1020 shop_type_npc_gui = 1021 shop_type_npc_gao = 1022 shop_type_npc_sun = 1023 shop_type_npc_qiming = 1024 shop_type_npc_zhangshun = 1025 shop_type_npc_chen = 1026 shop_type_npc_er_niang = 1027 shop_type_npc_shitou = 1028 shop_type_npc_jifang = 1029 shop_type_npc_zhu = 1030 shop_type_npc_bai = 1031 shop_type_npc_kai = 1032 shop_type_npc_linglang = 1033 shop_type_npc_verr_goldet = 1034 shop_type_npc_zhou = 1035 shop_type_task_ekaterina = 1036 shop_type_activity_aster = 1037 shop_type_task_tartaglia = 1038 shop_type_npc_harris = 1039 shop_type_activity_dragon_spine = 1040 shop_type_activity_treasure_map = 1041 shop_type_npc_yinian = 1042 shop_type_activity_sea_lamp = 1043 shop_type_activity_fleur_fair = 1044 shop_type_npc_changshun = 1045 shop_type_npc_bolai = 1046 shop_type_npc_ashanpo = 1047 shop_type_home = 1048 shop_type_home_limit = 1049 shop_type_npc_master_lu = 1050 shop_type_npc_goth = 1051 shop_type_costume = 1052 shop_type_npc_obata = 1053 shop_type_npc_qiuyue = 1054 shop_type_npc_ryouko = 1055 shop_type_inazuma_grocery = 1056 shop_type_inazuma_souvenir = 1057 shop_type_inazuma_restaurant = 1058 shop_type_npc_kuroda = 1059 shop_type_npc_kiminami_anna = 1060 shop_type_npc_tomoki = 1061 shop_type_npc_karpillia = 1062 shop_type_blacksmith_inazuma = 1063 shop_type_fish = 1064 shop_type_fish_liyue = 1065 shop_type_fish_inazuma = 1066 shop_type_npc_kiyoko = 1067 shop_type_expired_widget_mengde = 1068 shop_type_capture_animal_shop = 1069 shop_type_npc_yamashiro_kenta = 1070 shop_type_activity_channeller_slab = 15001 shop_type_activity_summer_time = 16001 shop_type_activity_bounce_conjuring = 16002 shop_type_activity_blitz_rush = 20001 shop_type_activity_chess = 20002 shop_type_activity_roguelike_dungeon = 20003 shop_type_activity_winter_camp = 20004 shop_type_activity_lantern_rite = 20005 shop_type_activity_rogue_diary = 27001 shop_type_activity_summer_time_v2 = 28001 class VegetationInteractType(Enum): displacement = 0 cut_grass = 1 none = 2 class ItemUseOp(Enum): item_use_none = 0 item_use_accept_quest = 1 item_use_trigger_ability = 2 item_use_gain_avatar = 3 item_use_add_exp = 4 item_use_relive_avatar = 5 item_use_add_big_talent_point = 6 item_use_add_persist_stamina = 7 item_use_add_temporary_stamina = 8 item_use_add_cur_stamina = 9 item_use_add_cur_hp = 10 item_use_add_elem_energy = 11 item_use_add_all_energy = 12 item_use_add_dungeon_cond_time = 13 item_use_add_weapon_exp = 14 item_use_add_server_buff = 15 item_use_del_server_buff = 16 item_use_unlock_cook_recipe = 17 item_use_open_random_chest = 20 item_use_make_gadget = 24 item_use_add_item = 25 item_use_grant_select_reward = 26 item_use_add_select_item = 27 item_use_gain_flycloak = 28 item_use_gain_name_card = 29 item_use_unlock_paid_battle_pass_normal = 30 item_use_gain_card_product = 31 item_use_unlock_forge = 32 item_use_unlock_combine = 33 item_use_unlock_codex = 34 item_use_chest_select_item = 35 item_use_gain_resin_card_product = 36 item_use_add_reliquary_exp = 37 item_use_unlock_furniture_formula = 38 item_use_unlock_furniture_suite = 39 item_use_add_channeller_slab_buff = 40 item_use_gain_costume = 41 item_use_add_treasure_map_bonus_region_fragment = 42 item_use_combine_item = 43 item_use_unlock_home_module = 44 item_use_unlock_home_bgm = 45 item_use_add_regional_play_var = 46 class ChannellerSlabCondition(Enum): channeller_slab_condition_none = 0 channeller_slab_condition_limit = 1 channeller_slab_condition_config = 2 channeller_slab_lineup_replace = 3 class ShopmallEntranceType(Enum): entrance_normal = 0 entrance_recharge = 1 entrance_tab = 2 class AiLodStrategyType(Enum): best = 0 npc = 1 monster = 2 minor_animal = 3 monster_vista = 4 count = 5 class PickType(Enum): none = 0 monster = 1 auto = 2 select = 3 attract = 4 auto_select = 5 group_auto = 6 class TrialAvatarTemplatePlaceholderType(Enum): trial_avatar_template_placeholder = 0 class LevelDayTimeType(Enum): day = 0 night = 1 class NarratorState(Enum): ing = 0 pausing = 1 class ParamLogicType(Enum): replace = 0 add = 1 class QuestType(Enum): aq = 0 fq = 1 lq = 2 eq = 3 dq = 4 iq = 5 vq = 6 wq = 7 class SceneObjState(Enum): normal = 0 burning = 1 burned = 2 cut = 3 frozen = 4 melt = 5 class CardProductType(Enum): card_product_type_invalid = 0 card_product_type_hcoin = 1 card_product_type_resin = 2 class QteStepCondType(Enum): qte_step_cond_none = 0 qte_step_cond_power_bar_value = 1 qte_step_cond_button_count_down_value = 2 class MoveStateMixinType(Enum): dash = 0 class CardFortuneType(Enum): chess_cardfortune_bad = 0 chess_cardfortune_normal = 1 chess_cardfortune_good = 2 chess_cardfortune_verygood = 3 chess_cardfortune_perfect = 4 class ShopRefreshType(Enum): shop_refresh_none = 0 shop_refresh_monthly = 1 shop_refresh_weekly = 2 shop_refresh_daily = 3 class SealProgressType(Enum): circle = 0 bar = 1 class CurtainType(Enum): none = 0 black_screen = 1 summer_time = 2 class DragonSpineMissionFinishExecType(Enum): dragon_spine_exec_type_none = 0 dragon_spine_exec_type_ban_drop = 1 dragon_spine_exec_type_clear_item = 2 class StackMethod(Enum): top = 0 sum = 1 multiplied = 2 one_minus_multiplied = 3 class IrodoriChessCardEffectType(Enum): irodori_chess_card_effect_default = 0 irodori_chess_card_effect_add_sgv = 1 irodori_chess_card_effect_add_gear_num = 2 irodori_chess_card_effect_mod_refund_by_cost = 3 irodori_chess_card_effect_add_ability_group = 4 irodori_chess_card_effect_add_target_gear_num = 5 irodori_chess_card_effect_lua_custom = 6 irodori_chess_card_effect_set_sgv = 7 class PropertyType(Enum): entity = 0 actor = 1 class StrengthenDungeonType(Enum): dungeon_type_none = 0 dungeon_type_boss = 1 dungeon_type_break = 2 dungeon_type_normal = 3 dungeon_type_daily = 4 dungeon_type_tower = 5 dungeon_type_effigy = 6 class GuidePlatformType(Enum): platform_ios = 0 platform_android = 1 platform_pc = 2 platform_ps4 = 3 class GadgetCameraBoxUiActionType(Enum): none = 0 movie_canvas = 1 class SceneVehicleSummonPointMapMarkType(Enum): none = 0 lantern_rite_ship = 1 class BattlePassScheduleRewardType(Enum): battle_pass_schedule_reward_weapon = 0 battle_pass_schedule_reward_wing = 1 class EShaderPlus(Enum): plus_hit_flash = 0 plus_emission = 1 plus_skill_emission = 2 plus_outer_glow = 3 class GuideAvatarAction(Enum): move = 0 attack = 1 class EShaderData(Enum): none = 0 character_frozen = 1 character_petrifaction = 2 character_die = 3 character_burning_to_ashes = 4 character_dissolve = 5 gadget_frozen = 6 gadget_petrifaction = 7 gadget_die = 8 avatar_die = 9 monster_equip_die = 10 monster_die = 11 character_clip = 12 character_alpha_blend = 13 class WatcherSystemListenType(Enum): none = 0 local_avatar = 1 team = 2 class PlatformRotType(Enum): platform_rot_none = 0 platform_rot_speed = 1 platform_rot_round = 2 class CheckHitLayerType(Enum): only_hit_box = 0 only_hit_scene = 1 only_hit_massive_entity = 2 both = 3 class SectrPlatformType(Enum): base = 0 pc = 1 mobile = 2 ps4base = 3 class FishStockType(Enum): fish_stock_type_none = 0 fish_stock_type_any = 1 fish_stock_type_day = 2 fish_stock_type_night = 3 class InvolveType(Enum): involve_none = 0 involve_only_single = 1 involve_single_multiple = 2 involve_dynamic_multiple = 3 involve_only_multiple = 4 class BartenderEffectType(Enum): bartender_origin_cup_ontable = 0 bartender_origin_cup_onhand = 1 bartender_mix_bar = 2 bartender_ingredients = 3 bartender_ingredients_pour_eff = 4 bartender_finish_cup_onhand = 5 bartender_finish_cup_ontable = 6 bartender_finish_cup_push = 7 bartender_finish_cup_over = 8 bartender_finish_pour_eff = 9 bartender_finish_cup_eff = 10 class CoopTemperamentType(Enum): coop_temperament_1 = 1 coop_temperament_2 = 2 coop_temperament_3 = 3 coop_temperament_4 = 4 class AvatarFashionType(Enum): fashion_type_none = 0 fashion_type_flycloak = 1 class RewardResourceType(Enum): elec = 0 fire = 1 grass = 2 ice = 3 rock = 4 water = 5 wind = 6 class RoguelikeCardType(Enum): roguelike_card_tpye_none = 0 roguelike_card_tpye_ssr = 1 roguelike_card_tpye_sr = 2 roguelike_card_tpye_r = 3 class CoopNodeType(Enum): coop_node_none = 0 coop_node_talk = 1 coop_node_select = 2 coop_node_cond = 3 coop_node_action = 4 coop_node_end = 5 class QteStepCameraPosType(Enum): qte_camera_pos_none = 0 qte_camera_pos_exit = 1 qte_camera_pos_relative_to_avatar = 2 class RoundRandomType(Enum): none = 0 floor = 1 ceil = 2 round = 3 class ScanAreaType(Enum): rectangle = 0 ellipse = 1 class CustomGadgetType(Enum): default = 0 furniture = 1 activity_flower_shelf_base = 2 activity_winter_camp_snowman_base = 3 class ControlPartTargetType(Enum): ai_threat_target = 0 action_set_target = 1 class SectrObjectType(Enum): object = 0 layer = 1 sector = 2 class DailyTaskCondType(Enum): daily_task_cond_none = 0 daily_task_cond_var_eq = 1 daily_task_cond_var_ne = 2 daily_task_cond_var_gt = 3 daily_task_cond_var_lt = 4 class MonsterCategory(Enum): all = 0 common = 1 elite = 2 boss = 3 enum_count = 4 class GuideHasAvatarType(Enum): normal = 0 in_team = 1 class ReminderStyleType(Enum): normal = 0 banner = 1 info_text_dialog = 2 event_prompt_down = 3 white_message = 4 class TargetAltitudeType(Enum): ground_only = 0 water_only = 1 both = 2 class RejectEventType(Enum): none = 0 has_attack_landed = 1 reject_all = 255 class MistTrialStatisticType(Enum): mist_trial_stat_type_none = 0 mist_trial_stat_type_finish_challenge_count = 1 mist_trial_stat_type_attack_by_gear_count = 2 mist_trial_stat_type_kill_monster_by_attack_tag = 3 mist_trial_stat_type_recover_hp_count = 4 mist_trial_stat_type_kill_shield_count = 5 mist_trial_stat_type_be_hurt_count = 6 mist_trial_stat_type_kill_monster_by_shield = 7 mist_trial_stat_type_disable_gear_count = 8 mist_trial_stat_type_element_reaction_type_num = 9 mist_trial_stat_type_element_reaction_count = 10 mist_trial_stat_type_element_burst_count = 11 mist_trial_stat_type_kill_monster_count = 12 class StoryCameraPosType(Enum): absolute = 0 relative_to_intee = 1 relative_to_inter = 2 relative_pos_to_intee = 3 relative_pos_to_inter = 4 exit = 5 relative_to_intee_only = 6 relative_to_inter_only = 7 relative_to_target_entity = 8 relative_to_multi_target_entity = 9 other = 10 class EnvZoneEventType(Enum): zone_animal = 1 zone_rand_task = 2 zone_rand_quest = 4 zone_ambush_monster = 8 class SettleShowType(Enum): settle_show_none = 0 settle_show_time_cost = 1 settle_show_open_chest_count = 2 settle_show_kill_monster_count = 3 settle_show_blackscreen = 4 class LunaRiteQuestType(Enum): luna_rite_quest_type_mainline = 0 luna_rite_quest_type_bigworld = 1 class CoopPointType(Enum): point_none = 0 point_start = 1 point_middle = 2 point_end = 3 class RetreatType(Enum): by_attacker = 0 by_hit_direction = 1 by_tangent = 2 by_origin_owner = 3 by_hit_direction_inverse = 4 by_attacker_forward = 5 by_attacker_inverse = 6 class GuideLongPressType(Enum): auto_end = 0 end = 1 begin = 2 click = 3 lasted = 4 class ChessCardType(Enum): chess_card_curse = 0 chess_card_mechanism = 1 chess_card_challenge = 2 chess_card_strengthen = 3 class StrikeType(Enum): default = 0 slash = 1 blunt = 2 pierce = 3 spear = 4 none = 5 class AudioPlatformMoveType(Enum): none = 0 linear = 1 angular = 2 both = 3 class InvestigationMonsterMapMarkCreateConditionType(Enum): invalid = 0 player_level_ge = 1 class ActionPointType(Enum): invalid_point = 0 sleep_point = 1 sit_point = 2 landing_point = 3 extraction_point = 4 dvalin_special_point = 5 lupi_colosseum_point = 6 dancing_point = 7 making_point = 8 building_point = 9 search_point = 10 supervise_point = 11 threat_point = 12 preach_point = 13 surround_point = 14 training_point = 15 mole_hole_point = 16 aureae_point = 17 standby_point = 18 sit_on_chair_point = 19 pray_point = 20 guard_point = 21 forge_point = 22 fishing_point = 23 kid_play_point = 24 drinking_point = 25 multi_talk_point = 26 multi_talk_prim_point = 27 shop_owner_point = 28 feeding_point = 29 watering_point = 30 sweeping_point = 31 shelter_point = 32 hiding_point = 33 oceanid_move_point = 34 afraid_point = 35 investigate_point = 36 operation_point = 37 arrange_point = 38 splash_point = 39 repair_point = 40 performing_point = 41 cat_feed_point = 42 dog_feed_point = 43 tanuki_target_point = 44 drake_deep_sea_swim_point = 45 mining_point = 46 class QuestGuideType(Enum): quest_guide_none = 0 quest_guide_location = 1 quest_guide_npc = 2 quest_guide_gadget = 3 quest_guide_show_or_hide_npc = 4 quest_guide_dungeon_entry = 5 class GivingMethod(Enum): giving_method_none = 0 giving_method_exact = 1 giving_method_group = 2 giving_method_vague_group = 3 giving_method_any_no_finish = 4 class MpPlayerSettleSyncType(Enum): mp_play_settle_sync_type_none = 0 mp_play_settle_sync_type_watcher_progress = 1 mp_play_settle_sync_type_mp_group_variable = 2 mp_play_settle_sync_type_statistic_value = 3 class WatcherSystemMixinType(Enum): element_reaction = 0 element_reaction_by_water = 1 element_reaction_by_grass = 2 element_reaction_by_bush = 3 attack_landed = 4 do_skill_succ_nomal_attack = 5 do_skill_succ_elemental_art = 6 do_skill_succ_elemental_burst = 7 element_shield_add = 8 global_sub_shield_add = 9 listen_ability_action = 10 local_avatar_hp_change = 11 get_first_wind_bullet = 12 get_second_wind_bullet = 13 spawn_wind_field_by_wind_bullet = 14 avatar_state_id_change = 15 avatar_weapon_element_override = 16 class FireworksReformParamType(Enum): fireworks_reform_param_none = 0 fireworks_reform_param_color = 1 fireworks_reform_param_height = 2 fireworks_reform_param_size = 3 fireworks_reform_param_density = 4 fireworks_reform_param_rotation = 5 class TalkBeginWay(Enum): talk_begin_none = 0 talk_begin_auto = 1 talk_begin_manual = 2 class LevelOption(Enum): none = 0 dungeon_level = 1 world_level = 2 creator = 3 class PerfConfigPlatform(Enum): pc = 0 i_os = 1 android = 2 ps4 = 3 ps5 = 4 cloud = 5 switch = 6 class InputDeviceType(Enum): touch_screen = 0 keyboard_with_touch_screen = 1 keyboard_with_mouse = 2 joypad = 3 class HuntingMonsterFinishType(Enum): hunting_finish_type_none = 0 hunting_finish_type_all = 1 hunting_finish_type_target_monster = 2 class ActionSlotType(Enum): slot_am = 0 slot1 = 1 slot2 = 2 slot3 = 3 slot4 = 4 slot5 = 5 slot_left = 6 slot_charge = 7 slot_quick_use = 8 class WidgetEventType(Enum): collection_wind_seed = 1 class GuideButtonClick(Enum): click = 0 press_down = 1 charge = 2 toggle = 3 long_press = 4 class ContextEventType(Enum): invalid = 0 context_end = 1 frame_end = 2 close_event = 3 back_event = 4 confirm_event = 5 confirming_event = 6 confirming_cancel_event = 7 to_prev_primary_tab_event = 8 to_next_primary_tab_event = 9 to_prev_secondary_tab_event = 10 to_next_secondary_tab_event = 11 menu_navigation_up = 12 menu_navigation_down = 13 menu_navigation_left = 14 menu_navigation_right = 15 increase_count_event = 16 decrease_count_event = 17 trigger_input_event = 18 logout_confirming_event = 19 logout_confirm_end_event = 20 backing_event = 21 backing_cancel_event = 22 open_sorting_dropdown_event = 23 open_screen_dropdown_event = 24 revert_sorting_order_event = 25 open_dropdown_event = 26 to_next_dropdown_option_event = 27 to_prev_dropdown_option_event = 28 confirm_dropdown_select_event = 29 cancel_dropdown_select_event = 30 scroll_primary_scroller_event = 31 return_to_quest_event = 32 to_avatar1event = 33 to_avatar2event = 34 to_avatar3event = 35 to_avatar4event = 36 open_chat_event = 37 to_avatar5event = 38 action_north_event = 39 action_east_event = 40 action_south_event = 41 action_west_event = 42 show_item_detail_event = 43 show_player_level_reward_event = 44 change_team_event = 45 change_team_name_event = 46 fast_team_select_event = 47 submit_fast_team_select = 48 show_help_tips = 49 buy_resin = 51 change_focus_zone = 52 show_cycle_dungeon_only = 53 change_custom_mark_name = 54 remove_custom_mark = 55 open_chat_cancel_event = 56 increase_count_release_event = 57 decrease_count_release_event = 58 item_source_select_event = 59 challenge_interrupt_event = 60 to_next_scroller_option_event = 61 to_prev_scroller_option_event = 62 confirm_scroller_select_event = 63 cancel_scroller_select_event = 64 homeworld_create_custom_suite_event = 65 to_reward_detail_event = 100 to_prev_reward_event = 101 to_next_reward_event = 102 to_prev_main_quest_event = 103 to_next_main_quest_event = 104 toggle_chapter_fold = 105 navigate_to_quest_event = 106 scroll_sub_quest_event = 107 chapter_select_event = 108 choose_prev_chapter_event = 109 choose_next_chapter_event = 110 show_sub_quest_detail_event = 111 to_reward_page_event = 112 toggle_quest_tracking_event = 113 to_prev_tab_event = 200 to_next_tab_event = 201 use_event = 202 drop_event = 203 to_prev_row_event = 204 to_next_row_event = 205 to_prev_slot_event = 206 to_next_slot_event = 207 re_name_event = 300 ui_zoom_camera_event = 400 ui_details = 401 move_cursor_event = 500 zoom_in_map_event = 501 zoom_out_map_event = 502 common_left_stick_up_event = 600 common_left_stick_down_event = 601 common_left_stick_left_event = 602 common_left_stick_right_event = 603 common_change_view_event = 604 common_menu_up_event = 605 common_menu_left_event = 606 common_right_stick_left_event = 607 common_right_stick_right_event = 608 common_left_stick_button_event = 610 common_right_stick_button_event = 611 common_right_trigger_event = 612 common_left_trigger_event = 613 common_right_shoulder_event = 614 common_left_shoulder_event = 615 common_left_shoulder_release_event = 616 common_right_shoulder_release_event = 617 common_left_stick_vertical_event = 620 common_right_stick_vertical_event = 621 common_left_stick_horizontal_event = 622 common_right_stick_horizontal_event = 623 common_right_stick_up_event = 630 common_right_stick_down_event = 631 revive = 700 goddess_contribute_some = 800 goddess_contribute_all = 801 goddess_scroll_upgrade_reward = 802 toggle_spring_auto_use_event = 803 dialog_select_event = 900 to_next_dialog_event = 901 visitor_login_event = 1000 switch_server_login_event = 1001 gacha_notice_event = 1020 gacha_history_event = 1021 gacha_once_event = 1022 gacha_ten_times_event = 1023 gacha_next_event = 1024 buy_event = 1101 tips_event = 1102 buy_info_event = 1103 mall_help_event = 1104 material_add_event = 1201 mcoin_add_event = 1202 hide_event = 1301 photograph_open_emotion = 1302 quick_use_event = 1401 activity_skill_event = 1402 extera_select_up_event = 1403 extera_select_down_event = 1404 extera_select_left_event = 1405 extera_select_right_event = 1406 music_game_left_up_event = 1407 music_game_left_right_event = 1408 music_game_left_down_event = 1409 music_game_left_left_event = 1410 music_game_right_up_event = 1411 music_game_right_right_event = 1412 music_game_right_down_event = 1413 music_game_right_left_event = 1414 music_game_left_up_released_event = 1415 music_game_left_right_released_event = 1416 music_game_left_down_released_event = 1417 music_game_left_left_released_event = 1418 music_game_right_up_released_event = 1419 music_game_right_right_released_event = 1420 music_game_right_down_released_event = 1421 music_game_right_left_released_event = 1422 music_game_free1event = 1423 music_game_free2event = 1424 music_game_free3event = 1425 music_game_free4event = 1426 music_game_free5event = 1427 music_game_free6event = 1428 music_game_free7event = 1429 music_game_free8event = 1430 music_game_free9event = 1431 music_game_free10event = 1432 music_game_free11event = 1433 music_game_free12event = 1434 music_game_free13event = 1435 music_game_free14event = 1436 music_game_free15event = 1437 music_game_free16event = 1438 music_game_free17event = 1439 music_game_free18event = 1440 music_game_free19event = 1441 music_game_free20event = 1442 music_game_free21event = 1443 music_game_pause_event = 1444 open_team_page_event = 1445 open_friend_page_event = 1446 common_left_trigger_press_event = 1447 common_left_trigger_release_event = 1448 common_right_trigger_press_event = 1449 common_right_trigger_release_event = 1450 arrow_up_event = 1451 arrow_down_event = 1452 arrow_left_event = 1453 arrow_right_event = 1454 left_control_event = 1455 left_control_released_event = 1456 space_event = 1457 space_released_event = 1458 undo_event = 1459 save_event = 1460 open_menu_event = 1461 open_menu_release_event = 1462 class ControlPartRotateBy(Enum): world_xz = 0 forward_trans_local = 1 class TileCampType(Enum): enviro = 0 fix_camp_id = 1 owner_camp = 2 class GuideTriggerType(Enum): player_level = 0 any_avatar_level = 1 get_new_item = 2 openstate_change = 3 has_avatar_num = 4 personalline_key = 5 climate_type_change = 6 worldplayer_update = 7 pushtips_notify_finish = 8 new_pushtips = 9 class DamageClampType(Enum): hp_max_percent = 0 hp_cur_percent = 1 damage_constant = 2 class GadgetUiItemShowCondType(Enum): none = 0 host = 1 guest = 2 custom_coop_frame_check = 3 class LocalGadgetCmdExeType(Enum): localgadget_cmd_instant = 0 class ActivityShopSheetCondType(Enum): activity_shop_sheet_cond_none = 0 activity_shop_sheet_cond_quest_finish = 1 activity_shop_sheet_cond_time_equal_greater = 2 activity_shop_sheet_cond_sea_lamp_phase = 3 class DisplayItemType(Enum): reliquary_item = 0 bartender_item = 1 default_item = 100 class FightPropType(Enum): fight_prop_none = 0 fight_prop_base_hp = 1 fight_prop_hp = 2 fight_prop_hp_percent = 3 fight_prop_base_attack = 4 fight_prop_attack = 5 fight_prop_attack_percent = 6 fight_prop_base_defense = 7 fight_prop_defense = 8 fight_prop_defense_percent = 9 fight_prop_base_speed = 10 fight_prop_speed_percent = 11 fight_prop_hp_mp_percent = 12 fight_prop_attack_mp_percent = 13 fight_prop_critical = 20 fight_prop_anti_critical = 21 fight_prop_critical_hurt = 22 fight_prop_charge_efficiency = 23 fight_prop_add_hurt = 24 fight_prop_sub_hurt = 25 fight_prop_heal_add = 26 fight_prop_healed_add = 27 fight_prop_element_mastery = 28 fight_prop_physical_sub_hurt = 29 fight_prop_physical_add_hurt = 30 fight_prop_defence_ignore_ratio = 31 fight_prop_defence_ignore_delta = 32 fight_prop_fire_add_hurt = 40 fight_prop_elec_add_hurt = 41 fight_prop_water_add_hurt = 42 fight_prop_grass_add_hurt = 43 fight_prop_wind_add_hurt = 44 fight_prop_rock_add_hurt = 45 fight_prop_ice_add_hurt = 46 fight_prop_hit_head_add_hurt = 47 fight_prop_fire_sub_hurt = 50 fight_prop_elec_sub_hurt = 51 fight_prop_water_sub_hurt = 52 fight_prop_grass_sub_hurt = 53 fight_prop_wind_sub_hurt = 54 fight_prop_rock_sub_hurt = 55 fight_prop_ice_sub_hurt = 56 fight_prop_effect_hit = 60 fight_prop_effect_resist = 61 fight_prop_freeze_resist = 62 fight_prop_dizzy_resist = 64 fight_prop_freeze_shorten = 65 fight_prop_dizzy_shorten = 67 fight_prop_max_fire_energy = 70 fight_prop_max_elec_energy = 71 fight_prop_max_water_energy = 72 fight_prop_max_grass_energy = 73 fight_prop_max_wind_energy = 74 fight_prop_max_ice_energy = 75 fight_prop_max_rock_energy = 76 fight_prop_skill_cd_minus_ratio = 80 fight_prop_shield_cost_minus_ratio = 81 fight_prop_cur_fire_energy = 1000 fight_prop_cur_elec_energy = 1001 fight_prop_cur_water_energy = 1002 fight_prop_cur_grass_energy = 1003 fight_prop_cur_wind_energy = 1004 fight_prop_cur_ice_energy = 1005 fight_prop_cur_rock_energy = 1006 fight_prop_cur_hp = 1010 fight_prop_max_hp = 2000 fight_prop_cur_attack = 2001 fight_prop_cur_defense = 2002 fight_prop_cur_speed = 2003 fight_prop_nonextra_attack = 3000 fight_prop_nonextra_defense = 3001 fight_prop_nonextra_critical = 3002 fight_prop_nonextra_anti_critical = 3003 fight_prop_nonextra_critical_hurt = 3004 fight_prop_nonextra_charge_efficiency = 3005 fight_prop_nonextra_element_mastery = 3006 fight_prop_nonextra_physical_sub_hurt = 3007 fight_prop_nonextra_fire_add_hurt = 3008 fight_prop_nonextra_elec_add_hurt = 3009 fight_prop_nonextra_water_add_hurt = 3010 fight_prop_nonextra_grass_add_hurt = 3011 fight_prop_nonextra_wind_add_hurt = 3012 fight_prop_nonextra_rock_add_hurt = 3013 fight_prop_nonextra_ice_add_hurt = 3014 fight_prop_nonextra_fire_sub_hurt = 3015 fight_prop_nonextra_elec_sub_hurt = 3016 fight_prop_nonextra_water_sub_hurt = 3017 fight_prop_nonextra_grass_sub_hurt = 3018 fight_prop_nonextra_wind_sub_hurt = 3019 fight_prop_nonextra_rock_sub_hurt = 3020 fight_prop_nonextra_ice_sub_hurt = 3021 fight_prop_nonextra_skill_cd_minus_ratio = 3022 fight_prop_nonextra_shield_cost_minus_ratio = 3023 fight_prop_nonextra_physical_add_hurt = 3024 class PersistentFurnitureType(Enum): wall = 0 floor = 1 ceil = 2 chandelier = 3 door = 4 stair = 5 invalid = 6 class ConfigShadowResolution(Enum): low = 0 medium = 1 high = 2 very_high = 3 class PlayerDieType(Enum): player_die_none = 0 player_die_kill_by_monster = 1 player_die_kill_by_gear = 2 player_die_fall = 3 player_die_drawn = 4 player_die_abyss = 5 class SelectTargetsSortType(Enum): default = 0 reversed = 1 nearest = 2 random = 3 higher_score = 4 low_hp_ratio = 5 class DirectionAngleType(Enum): free = 0 horizontal = 1 vertical = 2 class GachaType(Enum): gacha_type_newbie = 100 gacha_type_standard = 200 gacha_type_standard_avatar = 201 gacha_type_standard_weapon = 202 gacha_type_activity = 300 gacha_type_activity_avatar = 301 gacha_type_activity_weapon = 302 gacha_type_special_activity_avatar = 400 class EFootprintPlatform(Enum): all = 0 all_no_tessellation = 1 pc_no_tessellation = 2 pc = 3 android = 4 ios = 5 ps4 = 6 ps = 7 class HideAndSeekSkillCategory(Enum): hide_and_seek_skill_category_none = 0 hide_and_seek_skill_category_hunter = 1 hide_and_seek_skill_category_prey = 2 class ScenePointType(Enum): normal = 0 tower = 1 portal = 2 other = 3 class TalentFilterCond(Enum): talent_filter_none = 0 talent_filter_fire_avatar = 1 talent_filter_elec_avatar = 2 talent_filter_water_avatar = 3 talent_filter_grass_avatar = 4 talent_filter_wind_avatar = 5 talent_filter_ice_avatar = 6 talent_filter_rock_avatar = 7 class AudioVoiceTrigger(Enum): invalid = 0 weather_monologue = 1 dialog = 2 dungeon_reminder = 3 animator_event = 4 fetter = 5 gacha = 6 join_team = 7 class ItemLimitRefreshType(Enum): item_limit_refresh_none = 0 item_limit_refresh_daily = 1 item_limit_refresh_monthly = 2 item_limit_refresh_persistent = 3 class ControlPartForwardBy(Enum): parent = 0 entity_forward = 1 named_transform = 2 class ConstValueType(Enum): const_value_game_time_per_day = 1 const_value_init_game_time = 2 const_value_init_team_avatar = 3 const_value_change_avatar_cd = 4 const_value_avatar_hp_recover = 5 const_value_dash_cost_stamina = 6 const_value_climb_cost_stamina = 7 const_value_climb_jump_cost_stamina = 8 const_value_swim_cost_stamina = 9 const_value_swim_dash_cost_stamina = 10 const_value_fly_cost_stamina = 11 const_value_fall_hurt = 12 const_value_pack_max_weight = 13 const_value_depot_max_weight = 14 const_value_kill_monster_exp = 15 const_value_player_world_scene_id = 16 const_value_player_pickup_range = 17 const_value_item_stack_max = 18 const_value_avatar_die_max_time = 19 const_value_defense_resist_ratio = 20 const_value_critical_limit = 21 const_value_block_refresh_param = 22 const_value_dungeon_keep_time = 23 const_value_adsorbate_pickup_range = 24 const_value_adsorbate_stay_time = 25 const_value_element_overload_max = 26 const_value_element_overload_reduce = 27 const_value_purge_decrement = 28 const_value_water_fire_decrate = 29 const_value_ice_fire_decrate = 30 const_value_effect_resist_level_fix = 31 const_value_dungeon_revive_wait_time = 32 const_value_food_weapon_exp_discount_param = 33 const_value_food_reliquary_exp_discount_param = 34 const_value_damage_level_fix = 35 const_value_dungeon_cancel_wait_time = 36 const_value_endure_level_fix = 37 const_value_secret_chest_day_limit = 38 const_value_hurt_revive_hp_percent = 39 const_value_no_hurt_die_sub_hp_percent = 40 const_value_spring_recover_time = 41 const_value_spring_recover_param = 42 const_value_spring_auto_recover_delay = 43 const_value_back_avatar_auto_recover_param = 44 const_value_stamina_limit = 45 const_value_bored_limit = 46 const_value_bored_create_monster = 47 const_value_skill_cd_min_preserve_time = 48 const_value_talent_point_limit = 49 const_value_elementreaction_arealeveldelta_limit = 50 const_value_bored_enable_quest_id = 51 const_value_extra_stamina_limit = 52 const_value_modifier_min_preserve_time = 53 const_value_nickname_max_length = 54 const_value_area_check_cd = 55 const_value_portal_transport_time = 56 const_value_env_animal_refresh = 58 const_value_env_animal_group = 59 const_value_bush_drop = 61 const_value_cook_auto_quality = 62 const_value_kill_drop_exp_config = 63 const_value_avatar_max_promote_level = 64 const_value_violin_list = 65 const_value_crouch_roll_cost_stamina = 66 const_value_stamina_recover_wait_time = 67 const_value_fireworm_escape_parma = 68 const_value_timeout_second_parma = 69 const_value_timeout_cound_parma = 70 const_value_dash_bs_cost_stamina = 71 const_value_mail_max_num = 72 const_value_record_monster_dis = 73 const_value_record_monster_angle = 74 const_value_compound_queue_max_count = 75 const_value_weapon_auto_hide_time = 76 const_value_weapon_levelup_cost = 77 const_value_reliquary_levelup_cost = 78 const_value_climb_min_stamina = 79 const_value_element_show_distance = 80 const_value_walk_to_swim_add_stamina = 81 const_value_questguide_show_distance = 82 const_value_limit_quality_ondrop = 83 const_value_steer_min_angle = 84 const_value_map_warning_distance = 85 const_value_map_warning_interval = 86 const_value_area_level_warning_thr = 87 const_value_superconductor_durability = 88 const_value_swirl_param = 89 const_value_is_mp_open = 91 const_value_crash_param = 92 const_value_element_mastery_param = 93 const_value_daily_task_param = 94 const_value_next_day = 95 const_value_rand_task_refresh_param = 96 const_value_rand_task_pos_param = 97 const_value_energy_rechange_ratio = 98 const_value_default_world_id = 99 const_value_rand_task_qest_param = 100 const_value_rand_task_comp_param = 101 const_value_expedition_init_limit = 102 const_value_world_level_formula = 103 const_value_swim_dash_cost_stamina_per_second = 104 const_value_rand_task_point_param = 105 const_value_weather_interval = 106 const_value_dungeon_daily_item = 107 const_value_dungeon_weekly_item = 108 const_value_avatar_combat_force_param = 109 const_value_player_combat_force_param = 110 const_value_core_proud_skill_max_level = 111 const_value_inherent_proud_skill_max_level = 112 const_value_active_skill_max_level = 113 const_value_cook_qte_perfect_range_value = 114 const_value_teamname_max_length = 115 const_value_dungeon_oepn_quest = 116 const_value_mp_chat_param = 117 const_value_climb_cost_stamina_formula = 118 const_value_climb_jump_cost_stamina_formula = 119 const_value_dungeon_candidate_invite_vaild_time_sec = 120 const_value_set_struggle_level_difference_threshold = 121 const_value_dungeon_invite_need_trans_distance = 122 const_value_player_level_reward_unlock_preview_limit = 123 const_value_drop_subfield_param = 124 const_value_npc_conflict_distance = 125 const_value_sea_lamp_activity = 126 const_value_activity = 127 const_value_avatar_upgrade_cost_ratio = 128 const_value_sea_lamp_pray_url = 129 const_value_sea_lamp_activity2 = 130 const_value_daily_task_param2 = 131 const_value_sea_lamp_quest = 132 const_value_daily_task_open_custom_pool = 133 const_value_resin_param = 134 const_value_resin_buying_cost = 136 const_value_tower_daily_mail_id = 138 const_value_tower_monthly_mail_id = 139 const_value_tower_overflow_first_pass = 140 const_value_limit_region_path = 141 const_value_sea_lamp_activity3 = 142 const_value_default_material_gadget_id = 144 const_value_distance_check = 145 const_value_proficient_player_child_quest = 146 const_value_gacha_guarantee_start_coefficient = 147 const_value_gacha_guarantee_increase_coefficient = 148 const_value_gacha_dynamic_up_base = 149 const_value_quest_trial_avatar_combat_force_convert_ratio = 150 const_value_output_limit_switch = 151 const_value_output_control_switch = 152 const_value_fromback_limittime = 153 const_value_fromback_limitratio = 154 const_value_reconnect_delay_base = 155 const_value_fromback_reconnect_duration = 156 const_value_force_reconnect_duration = 157 const_value_social_config = 158 const_value_battle_pass_mission_refresh = 159 const_value_product_param = 160 const_value_satiation_param = 161 const_value_mall_limittimept_showtime = 162 const_value_gagdet_creation_limit_drop_tag = 163 const_value_loading_light_bg_period = 164 const_value_dungeon_level_limit = 165 const_value_move_speed_check_param = 166 const_value_disconnecthint_timeout_seconds = 167 const_value_bag_overflow_mail_id = 168 const_value_activity_crucible_quest_id = 169 const_value_mp_play_config = 170 const_value_rebate_mail_id = 172 const_value_crucible_config = 173 const_value_default_flycloak_config = 174 const_value_default_name_card_id = 175 const_value_material_item_limit = 176 const_value_reliquary_item_limit = 177 const_value_weapon_item_limit = 178 const_value_battlepass_video_config = 180 const_value_material_destroy_return_material_limit = 181 const_value_battle_pass_item_use_config = 182 const_value_activity_newbee_id = 183 const_value_personal_line_config = 184 const_value_rtt_low = 185 const_value_rtt_mid = 186 const_value_rtt_high = 187 const_value_rtt_refresh_time = 188 const_value_speech_bubble_default_duration = 189 const_value_speech_bubble_extra_duration = 190 const_value_forge_point_day_limit = 191 const_value_first_share_reward = 192 const_value_point_card_recharge = 193 const_value_explore = 194 const_value_map_mark_max_length = 195 const_value_guide_rating_chapterid = 196 const_value_ps4_trophy_switch = 197 const_value_aster_middle_recover = 198 const_value_aster_middle_npc_talk_id = 199 const_value_hunting_revise_level = 200 const_value_reminder_interrupt_show_delay = 201 const_value_upgrade_weapon_return_material_id = 202 const_value_city_reputation_param = 203 const_value_report_param = 204 const_value_dragon_spine_config = 205 const_value_dungeon_restart_invite_vaild_time_sec = 206 const_value_reunion_param = 207 const_value_tower_reset = 208 const_value_snow_mountain_routine = 209 const_value_element_trial_mark_show_level_limit = 210 const_value_anti_harassment_config = 211 const_value_dragon_spine_mp_play_config = 212 const_value_die_invincible_config = 213 const_value_grass_tile_element_reaction_pos_offset = 214 const_value_ask_add_friend_frequency_config = 215 const_value_blessing_config = 216 const_value_miracle_ring_cd = 217 const_value_miracle_ring_drop_count = 218 const_value_miracle_ring_deliver_value = 219 const_value_miracle_ring_random_drop_prob = 220 const_value_miracle_ring_item_add_pack = 221 const_value_mp_reward_reserved_time_config = 222 const_value_chat_param = 223 const_value_activity_expedition_daily_refresh_path_limit = 224 const_value_activity_expedition_daily_count_limit = 225 const_value_activity_expedition_super_elem_coef = 226 const_value_activity_monster_banner_drake_primo_rock = 227 const_value_shop_output_switch = 228 const_value_mechanicus_rotation_param = 229 const_value_mechanicus_card_param = 230 const_value_force_drag_back_param = 231 const_value_activity_expedition_content_duration = 232 const_value_activity_expedition_challenge_hint_cd = 233 const_value_muip_mail_reward_limit = 234 const_value_arena_challenge_reward_worktop = 235 const_value_activity_water_sprite_para = 236 const_value_world_level_adjust = 237 const_value_nechanicus_open_questid = 238 const_value_activity_water_sprite_para_secondpart = 239 const_value_coop_questid_interval = 240 const_value_hit_tree_drop_param = 241 const_value_hit_tree_drop_prob = 243 const_value_default_home_world_id = 244 const_value_home_speechbubble_default_delay = 245 const_value_home_speechbubble_default_interval = 246 const_value_home_speechbubble_priority = 247 const_value_home_greet_dist_min = 248 const_value_home_greet_dist_max = 249 const_value_home_greet_angle_max = 250 const_value_home_greet_turn_angle = 251 const_value_home_greet_turn_duration = 252 const_value_multi_play_fetter_exp_ratio = 253 const_value_room_minimap_default_scale = 254 const_value_home_furniture_type_limit = 255 const_value_home_furniture_arrangement_cost_level = 256 const_value_home_lego_height = 257 const_value_home_accelerate_param = 258 const_value_home_weekend_djinn_param = 259 const_value_activity_effigy_ice = 260 const_value_activity_homeworld = 261 const_value_homeworld_tutrial_quest = 262 const_value_channeller_slab_single_buff_energy_limit = 263 const_value_channeller_slab_mp_buff_energy_limit = 264 const_value_home_resource_produce_interval = 265 const_value_weekly_boss_resin_discount_param = 266 const_value_bush_drop_cacha_num = 267 const_value_general_match = 268 const_value_home_djinn_param = 269 const_value_furniture_item_limit = 270 const_value_summer_time_scene_id = 271 const_value_can_not_destroy_material_type_list = 272 const_value_dangerzone_get_lost_countdown = 273 const_value_skiff_sprint_cost_stamina = 274 const_value_skiff_dash_cost_stamina = 275 const_value_signal_active_distance = 276 const_value_default_costume_icon = 277 const_value_hero_course_transfer_config = 278 const_value_vehicle_config = 279 const_value_home_greet_leave_delay = 280 const_value_chess_params = 281 const_value_genshin_release_time = 282 const_value_init_home_time = 283 const_value_home_cd_limit = 300 const_value_home_furniture_num_limit = 301 const_value_home_resource_base_value = 302 const_value_home_prior_check_time_range = 303 const_value_home_plant_box = 304 const_value_home_wait_enter_edit_finish_rsp = 305 const_value_home_furniture_arrangement_cost_level_hall = 350 const_value_home_furniture_arrangement_cost_level_room = 351 const_value_home_comfort_modifer = 352 const_value_home_suite_furniture_id = 353 const_value_home_furniture_group_num_limit = 354 const_value_home_furniture_group_record_num_limit = 355 const_value_home_furniture_custom_suite_param = 356 const_value_battlepass_purchase_about_to_close_threshold = 400 const_value_battlepass_purchase_close_ahead_minutes = 401 const_value_activity_daoqi_advertisement = 410 const_value_map_mark_param = 411 const_value_gather_savetype_to_gatherid = 412 const_value_home_npc_event_transfer_time = 413 const_value_activity_effigy_fire = 414 const_value_activity_perpetual = 415 const_value_mechanicus_2_attack = 416 const_value_mechanicus_2_mastery = 417 const_value_mechanicus_2_attack_speed = 418 const_value_mechanicus_2_alert_range = 419 const_value_condense_resinre_place_resin_count = 420 const_value_blossom_bag_reward_radius = 422 const_value_element_mastery_param_overdose = 423 const_value_gadget_interact_check_distance = 424 const_value_chess_card_config = 425 const_value_psn_social_config = 426 const_value_sumo_activity_config = 427 const_value_fishing = 428 const_value_default_weather_area_id = 429 const_value_emoji_collect_num_limit = 431 const_value_activity_expedition_2_params = 440 const_value_qiandaogua_params = 441 const_value_custom_gadget_parts_max_num = 442 const_value_dig_activity_hint_rand_degree = 443 const_value_roguelike_activity_params = 444 const_value_moonfin_banner = 445 const_value_minors_gacha_param = 446 const_value_fireworks_launch_param = 447 const_value_michiae_matsuri_activity_regional_play_params = 448 const_value_michiae_matsuri_activity_dark_presure_max_params = 449 const_value_custom_dungeon_recommend_1 = 450 const_value_custom_dungeon_recommend_2 = 451 const_value_custom_dungeon_recommend_filt = 452 const_value_custom_dungeon = 453 const_value_collectible_mail_param = 460 const_value_player_npc = 461 const_value_sharecd_server_buffer_time = 462 const_value_customlevel_customsuite_block_max_num = 463 const_value_codex_guide_papam = 464 const_value_ban_new_language_show = 465 const_value_packet_loss_warning_threshold = 470 const_value_packet_loss_warning_interval = 471 const_value_achievement_search_pattern_limit = 480 const_value_send_questionnaire_mail_logout_time = 481 const_value_send_questionnaire_mail_cd_time = 482 const_value_night_crow_config = 483 const_value_handbook_quest_guide_max_num = 484 const_value_summer_time_portal_loading = 485 const_value_achievement_search_limit = 600 class PushTipsType(Enum): push_tips_none = 0 push_tips_tutorial = 1 push_tips_monster = 2 class DistType(Enum): euler = 0 euler_xz = 1 class MoveToDirectionType(Enum): forward = 0 backward = 1 left = 2 right = 3 class ClimateSourceType(Enum): none = 0 climate = 1 other = 2 all = 3 class IrodoriChessCardType(Enum): irodori_chess_card_mechanism = 0 irodori_chess_card_strengthen = 1 class FireworksType(Enum): none = 0 spherical_fireworks = 1 pattern_shape_fireworks = 2 class OutputControlType(Enum): output_control_none = 0 output_control_drop = 1 output_control_reward = 2 output_control_other = 3 class ProjectionGameGuideType(Enum): input = 0 switch = 1 class CoopCgType(Enum): cg_none = 0 cg_male = 1 cg_female = 2 class VehicleLimitType(Enum): vehicle_limit_none = 0 vehicle_limit_only_vehicle = 1 vehicle_limit_not_vehicle = 2 class CoopCondType(Enum): coop_cond_none = 0 coop_cond_temperament_compare = 1 coop_cond_confidence_compare = 2 coop_cond_ending_finish = 3 coop_cond_quest_finish = 4 coop_cond_item_num_compare = 5 coop_cond_player_level_compare = 6 coop_cond_fetter_compare = 7 coop_cond_temp_value_compare = 8 class TauntLevel(Enum): ability_taunt_level_1 = 0 ability_taunt_level_2 = 1 ability_taunt_level_3 = 2 ability_taunt_level_4 = 3 ability_taunt_level_5 = 4 ability_taunt_level_max = 10 monster_taunt_level_1 = 11 monster_taunt_level_2 = 12 monster_taunt_level_3 = 13 monster_taunt_level_4 = 14 monster_taunt_level_5 = 15 monster_taunt_level_6 = 16 monster_taunt_level_max = 20 class ItemUseTarget(Enum): item_use_target_none = 0 item_use_target_cur_avatar = 1 item_use_target_cur_team = 2 item_use_target_specify_avatar = 3 item_use_target_specify_alive_avatar = 4 item_use_target_specify_dead_avatar = 5 class ExhibitionDisplayCondParamType(Enum): exhibition_display_cond_param_none = 0 exhibition_display_cond_param_replaceable_value = 1 exhibition_display_cond_param_accumulable_value = 2 exhibition_display_cond_param_unsigned_integer = 3 exhibition_display_cond_param_display_value = 4 class BrickRotateType(Enum): brick_rotate_none = 0 brick_rotate_45 = 1 brick_rotate_90 = 2 class DungeonStateType(Enum): dungeon_state_none = 0 dungeon_state_release = 1 dungeon_state_test = 2 class ServerBuffType(Enum): server_buff_none = 0 server_buff_avatar = 1 server_buff_team = 2 server_buff_tower = 3 class MaterialExpireType(Enum): count_down = 1 date_time = 2 delay_week_count_down = 3 class PerfOptionOverrideRule(Enum): force = 0 min = 1 max = 2 class HomeAvatarEventCondType(Enum): home_avatar_cond_none = 0 home_avatar_cond_fetter_level = 1 home_avatar_cond_exp_level = 2 class TalentType(Enum): none = 0 core_proud_skill = 1 inherent_proud_skill = 2 avatar_skill = 3 class ActionEventType(Enum): any = 0 button_pressed = 1 button_released = 2 button_pressing = 3 button_unpressing = 4 button_long_pressed = 5 button_long_pressing = 6 button_long_released = 7 button_short_press_up = 8 button_repeating = 9 axis_active = 10 negative_button_repeating = 11 class CoopTaskCondType(Enum): coop_cond_none = 0 coop_cond_finish_quest = 1 coop_cond_player_level = 2 coop_cond_coop_point_finish = 3 coop_cond_avatar_fetter_level = 4 coop_cond_chapter_end_all_finish = 5 coop_cond_chapter_end_finish_count = 6 class EndureType(Enum): none = 0 default = 1 avatar_sword = 2 avatar_pole = 3 avatar_claymore = 4 avatar_bow = 5 avatar_catalyst = 6 monster_minion = 7 monster_grunt_humanoid = 8 monster_grunt_other = 9 monster_demiboss_humanoid = 10 monster_demiboss_other = 11 monster_boss_humanoid = 12 monster_boss_other = 13 monster_slime = 14 monster_tartaglia = 15 monster_shougun = 16 class PlayMode(Enum): play_mode_all = 0 play_mode_single = 1 play_mode_multiple = 2 play_mode_host = 3 play_mode_guest = 4 class ActionTokenType(Enum): never_token = 0 frame_delay_token = 1 frame_cancel_token = 2 class UgcRayTriggerDirectionType(Enum): up = 0 down = 1 left = 2 right = 3 front = 4 back = 5 class OptionType(Enum): default = 0 very_low = 1 low = 2 medium = 3 high = 4 very_high = 5 class RogueDiaryBuffEffectType(Enum): rogue_diary_buff_effect_none = 0 rogue_diary_buff_effect_ability = 1 rogue_diary_buff_effect_unlock_talent = 2 class ButtonGuideType(Enum): normal = 0 red = 1 blink = 2 bubble = 3 class FindHilichurlAssignmentType(Enum): assignment_type_giving = 0 assignment_type_fight = 1 class SwitchSkillPriority(Enum): base = 0 avatar_common = 4 avatar_special = 5 playmode = 101 quest = 102 class WatcherTriggerType(Enum): trigger_none = 0 trigger_combat_config_common = 1 trigger_element_view = 2 trigger_enter_airflow = 5 trigger_new_monster = 6 trigger_new_affix = 8 trigger_change_input_device_type = 9 trigger_paimon_angry_voice_easter_egg = 10 trigger_wind_crystal = 11 trigger_element_ball = 101 trigger_world_level_up = 102 trigger_dungeon_entry_to_be_explored = 103 trigger_unlock_gate_temple = 104 trigger_unlock_area = 105 trigger_unlock_trans_point = 106 trigger_open_chest_with_gadget_id = 107 trigger_city_level_up = 108 trigger_monster_die = 109 trigger_platform_start_move = 110 trigger_group_notify = 111 trigger_element_type_change = 112 trigger_gadget_interactable = 113 trigger_collect_set_of_readings = 114 trigger_teleport_with_certain_portal = 115 trigger_world_gather = 116 trigger_take_general_reward = 117 trigger_battle_for_monster_die_or = 118 trigger_battle_for_monster_die_and = 119 trigger_open_world_chest = 120 trigger_enter_climate_area = 121 trigger_unlock_scene_point = 122 trigger_interact_gadget_with_interact_id = 123 trigger_take_dungeon_first_pass_reward = 124 trigger_obtain_avatar = 201 trigger_player_level = 202 trigger_avatar_upgrade = 203 trigger_avatar_promote = 204 trigger_weapon_upgrade = 205 trigger_weapon_promote = 206 trigger_reliquary_upgrade = 207 trigger_wear_reliquary = 208 trigger_upgrade_talent = 209 trigger_unlock_recipe = 210 trigger_reliquary_set_num = 211 trigger_obtain_material_num = 212 trigger_obtain_reliquary_num = 213 trigger_gacha_num = 214 trigger_any_reliquary_upgrade = 215 trigger_fetter_level_avatar_num = 216 trigger_skilled_at_recipe = 217 trigger_reliquary_upgrade_equal_rank_level = 218 trigger_specified_weapon_upgrade = 219 trigger_specified_weapon_awaken = 220 trigger_unlock_specific_recipe_or = 221 trigger_possess_material_num = 222 trigger_exhibition_accumulable_value = 223 trigger_exhibition_replaceable_value_settle_num = 224 trigger_any_weapon_upgrade_num = 225 trigger_any_reliquary_upgrade_num = 226 trigger_activity_score_exceed_value = 227 trigger_unlock_specific_forge_or = 228 trigger_unlock_specific_animal_codex = 229 trigger_obtain_item_num = 230 trigger_capture_animal = 231 trigger_avatar_promote_excluding_player = 232 trigger_daily_task = 301 trigger_rand_task = 302 trigger_avatar_expedition = 303 trigger_finish_tower_level = 304 trigger_world_boss_reward = 306 trigger_finish_dungeon = 307 trigger_start_avatar_expedition = 308 trigger_open_blossom_chest = 309 trigger_finish_blossom_progress = 310 trigger_done_tower_gadget_unhurt = 311 trigger_done_tower_stars = 312 trigger_done_tower_unhurt = 313 trigger_steal_food_times = 314 trigger_done_dungeon_with_same_element_avatars = 315 trigger_group_flight_challenge_reach_points = 316 trigger_finish_daily_delivery_num = 317 trigger_tower_stars_num = 318 trigger_finish_specifed_type_blossom_num = 319 trigger_finish_specifed_type_blossom_climate_meter = 320 trigger_finish_blossom_group_variable_gt = 321 trigger_effigy_challenge_score = 322 trigger_finish_routine = 323 trigger_activity_expedition_finish = 324 trigger_activity_channeller_slab_finish_all_camp = 325 trigger_activity_channeller_slab_finish_all_oneoff_dungeon = 326 trigger_activity_channeller_slab_loop_dungeon_total_score = 327 trigger_group_summer_time_sprint_boat_reach_points = 328 trigger_weekly_boss_kill = 329 trigger_bounce_conjuring_finish_count = 330 trigger_bounce_conjuring_score = 331 trigger_group_variable_set_value_to = 332 trigger_kill_gadgets_by_specific_skill = 333 trigger_kill_monsters_without_vehicle = 334 trigger_kill_monster_in_area = 335 trigger_enter_vehicle = 336 trigger_vehicle_duration = 337 trigger_vehicle_friends = 338 trigger_vehicle_killed_by_monster = 339 trigger_vehicle_dash = 340 trigger_do_cook = 401 trigger_do_forge = 402 trigger_do_compound = 403 trigger_do_combine = 404 trigger_buy_shop_goods = 405 trigger_forge_weapon = 406 trigger_mp_play_battle_win = 421 trigger_kill_group_monster = 422 trigger_crucible_element_score = 423 trigger_mp_dungeon_times = 424 trigger_mp_kill_monster_num = 425 trigger_crucible_max_ball = 426 trigger_crucible_max_score = 427 trigger_crucible_submit_ball = 428 trigger_crucible_world_level_score = 429 trigger_mp_play_group_statistic = 430 trigger_kill_group_specific_monster = 431 trigger_reach_mp_play_score = 432 trigger_reach_mp_play_record = 433 trigger_treasure_map_done_region = 434 trigger_sea_lamp_mini_quest = 435 trigger_finish_find_hilichurl_level = 436 trigger_combine_item = 437 trigger_finish_challenge_in_duration = 438 trigger_finish_challenge_left_time = 439 trigger_mp_kill_monster_id_num = 440 trigger_login = 501 trigger_cost_material = 502 trigger_deliver_item_to_salesman = 503 trigger_use_item = 504 trigger_accumulate_daily_login = 505 trigger_finish_challenge = 601 trigger_mechanicus_unlock_gear = 602 trigger_mechanicus_levelup_gear = 603 trigger_mechanicus_difficult = 604 trigger_mechanicus_difficult_score = 605 trigger_mechanicus_kill_monster = 606 trigger_mechanicus_building_point = 607 trigger_mechanicus_difficult_eq = 608 trigger_mechanicus_battle_end = 609 trigger_mechanicus_battle_end_excaped_less_than = 610 trigger_mechanicus_battle_end_points_more_than = 611 trigger_mechanicus_battle_end_gear_more_than = 612 trigger_mechanicus_battle_end_pure_gear_damage = 613 trigger_mechanicus_battle_end_card_pick_more_than = 614 trigger_mechanicus_battle_end_card_target_more_than = 615 trigger_mechanicus_battle_end_build_gear_more_than = 616 trigger_mechanicus_battle_end_gear_kill_more_than = 617 trigger_mechanicus_battle_end_round_more_than = 618 trigger_mechanicus_battle_end_round = 619 trigger_mechanicus_battle_fin_challenge_more_than = 620 trigger_mechanicus_battle_watcher_finish_count = 621 trigger_mechanicus_battle_interact_count = 622 trigger_mechanicus_battle_difficult_escape = 623 trigger_mechanicus_battle_difficult_gear_num = 624 trigger_mechanicus_battle_difficult_gear_id_num = 625 trigger_fleur_fair_dungeon_finish_in_limit_time = 626 trigger_fleur_fair_dungeon_finish_keep_energy = 627 trigger_fleur_fair_dungeon_finish_with_group_variable = 628 trigger_fleur_fair_dungeon_finish_with_buff_num = 629 trigger_fleur_fair_dungeon_mission_finish = 630 trigger_finish_dungeon_and_challenge_remain_time_greater_than = 631 trigger_finish_dungeon_with_mist_trial_stat = 632 trigger_dungeon_mist_trial_stat = 633 trigger_dungeon_element_reaction_num = 634 trigger_level_avatar_finish_dungeon_count = 635 trigger_chess_reach_level = 636 trigger_chess_dungeon_add_score = 637 trigger_chess_dungeon_succ_with_escaped_monsters_less_than = 638 trigger_chess_dungeon_succ_with_tower_count_less_or_equal = 639 trigger_chess_dungeon_succ_with_card_count_less_or_equal = 640 trigger_chess_dungeon_succ_with_card_count_greater_than = 641 trigger_chess_kill_monsters = 642 trigger_chess_cost_building_points = 643 trigger_sumo_stage_score_reach = 644 trigger_sumo_total_max_score_reach = 645 trigger_rogue_destroy_gadget_num = 646 trigger_rogue_kill_monster_num = 647 trigger_rogue_finish_without_using_spring_cell = 649 trigger_rogue_finish_all_challenge_cell = 650 trigger_rogue_finish_with_avatar_element_type_num_less_than = 651 trigger_rogue_finish_with_avatar_num_less_than = 652 trigger_rogue_finish_no_avatar_dead = 653 trigger_rogue_shikigami_upgrade = 654 trigger_rogue_curse_num = 655 trigger_rogue_select_card_num = 656 trigger_finish_quest_and = 700 trigger_finish_quest_or = 701 trigger_daily_task_var_equal = 702 trigger_quest_global_var_equal = 703 trigger_talk_num = 704 trigger_finish_parent_quest_and = 705 trigger_finish_parent_quest_or = 706 trigger_element_reaction_timelimit_num = 800 trigger_element_reaction_timelimit_kill_num = 801 trigger_element_reaction_timelimit_damage_num = 802 trigger_ability_state_pass_time = 803 trigger_max_critical_damage = 804 trigger_full_satiation_team_avatar_num = 805 trigger_killed_by_certain_monster = 806 trigger_cur_avatar_hurt = 807 trigger_cur_avatar_ability_state = 808 trigger_use_energy_skill_num_timelimit = 809 trigger_shield_source_num = 810 trigger_cur_avatar_hurt_by_specific_ability = 811 trigger_killed_by_specific_ability = 812 trigger_max_dash_time = 900 trigger_max_fly_time = 901 trigger_max_fly_map_distance = 902 trigger_sit_down_in_point = 903 trigger_dash = 904 trigger_climb = 905 trigger_fly = 906 trigger_city_reputation_level = 930 trigger_city_reputation_finish_request = 931 trigger_hunting_finish_num = 932 trigger_hunting_fail_num = 933 trigger_offering_level = 934 trigger_miracle_ring_deliver_item = 935 trigger_miracle_ring_take_reward = 936 trigger_blessing_exchange_pic_num = 937 trigger_blessing_redeem_reward_num = 938 trigger_gallery_balloon_reach_score = 939 trigger_gallery_fall_reach_score = 940 trigger_fleur_fair_music_game_reach_score = 941 trigger_main_coop_save_point_and = 942 trigger_main_coop_save_point_or = 943 trigger_main_coop_var_equal = 944 trigger_finish_all_arena_challenge_watcher_in_schedule = 945 trigger_gallery_buoyant_combat_reach_score = 946 trigger_buoyant_combat_reach_new_score_level = 947 trigger_place_miracle_ring = 948 trigger_luna_rite_search = 949 trigger_gallery_fish_reach_score = 950 trigger_gallery_triathlon_reach_score = 951 trigger_winter_camp_snowman_compleiet = 952 trigger_create_custom_dungeon = 953 trigger_publish_custom_dungeon = 954 trigger_play_other_custom_dungeon = 955 trigger_finish_custom_dungeon_official = 956 trigger_custom_dungeon_official_coin = 957 trigger_obtain_wood_type = 1000 trigger_obtain_wood_count = 1001 trigger_unlock_furniture_count = 1002 trigger_furniture_make = 1003 trigger_home_level = 1004 trigger_home_coin = 1005 trigger_home_comfort_level = 1006 trigger_home_limited_shop_buy = 1007 trigger_furniture_suite_type = 1008 trigger_arrangement_furniture_count = 1009 trigger_enter_self_home = 1010 trigger_home_module_comfort_value = 1011 trigger_home_enter_room = 1012 trigger_home_avatar_in = 1013 trigger_home_avatar_reward_event_count = 1014 trigger_home_avatar_talk_finish_count = 1015 trigger_home_avatar_reward_event_all_count = 1016 trigger_home_avatar_talk_finish_all_count = 1017 trigger_home_avatar_fetter_get = 1018 trigger_home_avatar_in_count = 1019 trigger_home_do_plant = 1020 trigger_arrangement_furniture = 1021 trigger_home_gather_count = 1022 trigger_home_field_gather_count = 1023 trigger_home_unlock_bgm_count = 1024 trigger_fishing_succ_num = 1100 trigger_fishing_keep_bonus = 1101 trigger_empty_fish_pool = 1102 trigger_fishing_fail_num = 1103 trigger_shock_fish_num = 1104 trigger_plant_flower_set_wish = 1105 trigger_plant_flower_give_flower = 1106 trigger_plant_flower_obtain_flower_type = 1107 trigger_plant_flower_common_obtain_flower_type = 1108 trigger_finish_lanv2_projection_level = 1111 trigger_gallery_salvage_reach_score = 1112 trigger_lanv2_fireworks_challenge_reach_score = 1113 trigger_potion_stage_level_pass_num = 1115 trigger_potion_stage_obtain_medal_num = 1116 trigger_potion_stage_reach_total_score = 1117 trigger_bartender_finish_story_module = 1120 trigger_bartender_challenge_module_level_score = 1121 trigger_bartender_unlock_formula = 1122 trigger_michiae_matsuri_unlock_crystal_skill_reach_num = 1123 trigger_michiae_matsuri_finish_dark_challenge_reach_num = 1124 trigger_capture_env_animal_reach_num = 1125 trigger_spice_make_formula_times = 1126 trigger_spice_give_food_times = 1127 trigger_spice_make_formula_successful_times = 1128 trigger_irodori_finish_flower_theme = 1131 trigger_irodori_finish_master_stage = 1132 trigger_irodori_chess_stage_reach_score = 1133 trigger_irodori_finish_poetry_theme = 1134 trigger_photo_finish_pos_id = 1135 trigger_crystal_link_level_score_reach = 1138 trigger_crystal_link_total_max_score_reach = 1139 trigger_luminance_stone_challenge_score_reach = 1140 trigger_gacha_finish_stage_id = 1141 trigger_gacha_make_robot_num = 1142 trigger_gacha_get_robot_num = 1143 trigger_gacha_give_robot_num = 1144 trigger_gacha_convert_robot_num = 1145 trigger_finish_rogue_diary_stage = 1151 trigger_finish_rogue_diary_stage_round = 1152 trigger_music_game_settle_others_ugc = 1153 trigger_music_game_save_ugc = 1154 trigger_gear_finish_level_id = 1161 trigger_gear_finish_jigsaw_picture = 1162 trigger_island_party_reach_score = 1165 class AiBasicMoveType(Enum): straight = 0 snakelike = 1 class GuideKeyClick(Enum): press_down = 0 click = 1 charge = 2 class EntityType(Enum): none = 0 avatar = 1 monster = 2 bullet = 3 attack_phyisical_unit = 4 aoe = 5 camera = 6 enviro_area = 7 equip = 8 monster_equip = 9 grass = 10 level = 11 npc = 12 trans_point_first = 13 trans_point_first_gadget = 14 trans_point_second = 15 trans_point_second_gadget = 16 drop_item = 17 field = 18 gadget = 19 water = 20 gather_point = 21 gather_object = 22 airflow_field = 23 speedup_field = 24 gear = 25 chest = 26 energy_ball = 27 elem_crystal = 28 timeline = 29 worktop = 30 team = 31 platform = 32 amber_wind = 33 env_animal = 34 seal_gadget = 35 tree = 36 bush = 37 quest_gadget = 38 lightning = 39 reward_point = 40 reward_statue = 41 mp_level = 42 wind_seed = 43 mp_play_reward_point = 44 view_point = 45 remote_avatar = 46 general_reward_point = 47 play_team = 48 offering_gadget = 49 eye_point = 50 miracle_ring = 51 foundation = 52 widget_gadget = 53 vehicle = 54 danger_zone = 55 echo_shell = 56 home_gather_object = 57 projector = 58 screen = 59 custom_tile = 60 fish_pool = 61 fish_rod = 62 custom_gadget = 63 roguelike_operator_gadget = 64 activity_interact_gadget = 65 black_mud = 66 sub_equip = 67 ui_interact_gadget = 68 night_crow_gadget = 69 place_holder = 99 class CutsceneType(Enum): none = 0 time_line_asset = 1 time_line_prefab = 2 time_line_scene = 3 other = 4 class ConfigSchedulePlatform(Enum): default_hight = 0 default_lowest = 1 pc = 2 ps4_high = 3 ps4_low = 4 switch = 5 ios_high = 6 ios_medium = 7 ios_low = 8 android_high = 9 android_medium = 10 android_low = 11 class IrodoriMasterLevelType(Enum): irodori_master_level_none = 0 irodori_master_level_noraml = 1 irodori_master_level_hard = 2 irodori_master_level_master = 3 class ConfigPreloadType(Enum): on_create = 0 on_combat = 1 on_scene_data_notify = 2 class ProductType(Enum): product_type_none = 0 product_type_hcoin = 1 product_type_card = 2 product_type_package = 3 product_type_play = 4 product_type_google_gift_card = 5 product_type_concert = 6 product_type_apple_gift_card = 7 product_type_psn_compensation = 8 class FurnitureDeployType(Enum): interior = 0 exterior = 1 interior_room = 2 interior_hall = 3 sky_box = 4 class TargetPosToSelfPosType(Enum): xz = 0 y = 1 xyz = 2 class IrodoriChessCardTag(Enum): irodori_card_tag_none = 0 irodori_card_tag_water = 1 irodori_card_tag_fire = 2 irodori_card_tag_ice = 3 irodori_card_tag_wind = 4 irodori_card_tag_electric = 5 irodori_card_tag_physics = 6 irodori_card_tag_bomb = 7 irodori_card_tag_trap = 8 irodori_card_tag_repel = 9 irodori_card_tag_character = 10 irodori_card_tag_other = 11 class ActivityBannerUiElementType(Enum): none = 0 unlock_tips = 1 finish_tips = 2 reward_scroller = 3 button_goto = 4 button_check = 5 animator = 6 info_tips = 7 class QuestGuideNpcSelectType(Enum): select_npc_none = 0 select_npc_by_playermale = 1 class OpennessFuncType(Enum): linear = 0 quadratic = 1 cubic = 2 class ModifierStacking(Enum): refresh = 0 unique = 1 prolong = 2 refresh_and_add_durability = 3 multiple = 4 multiple_refresh = 5 multiple_refresh_no_remove = 6 multiple_all_refresh = 7 global_unique = 8 overlap = 9 refresh_unique_durability = 10 class MassiveElementTriggerType(Enum): trigger_anti_fire = 0 trigger_burning = 1 trigger_explode = 2 trigger_superconductor = 3 trigger_melt = 4 trigger_steam = 5 trigger_freeze = 6 trigger_frozen = 7 trigger_electric_add = 8 trigger_vehicle_mute_ice = 9 count = 10 class QteStepCameraTargetType(Enum): qte_camera_tar_none = 0 qte_camera_tar_relative_to_avatar = 1 class UniqueModifierCond(Enum): greater = 0 smaller = 1 class RoguelikeCardLabel(Enum): roguelike_card_label_combat = 0 roguelike_card_label_level = 1 roguelike_card_label_rune = 2 roguelike_card_label_equipment = 3 class BuffStackType(Enum): buff_refresh = 0 buff_extend = 1 buff_stack = 2 class FishSkillCategory(Enum): fish_skill_category_none = 0 fish_skill_category_force = 1 fish_skill_category_bonus = 2 class PositionModifyState(Enum): all = 0 walk = 1 run = 2 none = 3 class DungeonType(Enum): dungeon_none = 0 dungeon_plot = 1 dungeon_fight = 2 dungeon_daily_fight = 3 dungeon_weekly_fight = 4 dungeon_discarded = 5 dungeon_tower = 6 dungeon_boss = 7 dungeon_activity = 8 dungeon_effigy = 9 dungeon_element_challenge = 10 dungeon_theatre_mechanicus = 11 dungeon_fleur_fair = 12 dungeon_channeller_slab_loop = 13 dungeon_channeller_slab_one_off = 14 dungeon_blitz_rush = 15 dungeon_chess = 16 dungeon_sumo_combat = 17 dungeon_roguelike = 18 dungeon_hachi = 19 dungeon_potion = 20 dungeon_mini_eldritch = 21 dungeon_ugc = 22 dungeon_gcg = 23 dungeon_crystal_link = 24 dungeon_irodori_chess = 25 dungeon_rogue_diary = 26 dungeon_dreamland = 27 dungeon_summer_v2 = 28 class RogueDiaryStageDifficultyType(Enum): rogue_diary_stage_difficulty_none = 0 rogue_diary_stage_difficulty_normal = 1 rogue_diary_stage_difficulty_hard = 2 rogue_diary_stage_difficulty_insane = 3 class SoundBankUnloadPolicy(Enum): never = 0 exit_stage = 1 cooldown = 2 class AudioScope(Enum): global_ = 0 local_ = 1 class SmaaQuality(Enum): low = 0 medium = 1 high = 2 ultra = 3 class SalesmanSpecialRewardType(Enum): special_reward = 0 special_material = 1 special_drop = 2 class AnimatorParamType(Enum): trigger = 0 bool = 1 int = 2 float = 3 class UgcAxialType(Enum): x = 0 y = 1 z = 2 class GeneralRoutineType(Enum): routine_type_none = 0 routine_snow_mountain = 1 class BartenderMixingState(Enum): light = 0 middle = 1 heavy = 2 class ExhibitionDisplayCondType(Enum): exhibition_display_cond_none = 0 exhibition_display_cond_a_ge_b = 1 exhibition_display_cond_and = 2 exhibition_display_cond_or = 3 exhibition_display_cond_return_a_if_b_meet = 4 exhibition_display_cond_return_true_if_b_meet = 5 exhibition_display_cond_scene_player_largest = 6 exhibition_display_cond_scene_player_smallest = 7 exhibition_display_cond_return_a_if_and_is_true = 8 class ParamMethod(Enum): replace = 0 add = 1 minus = 2 one_add_multipled = 3 negative = 4 class IndicatorOperator(Enum): and_ = 0 or_ = 1 class CookFoodType(Enum): cook_food_none = 0 cook_food_heal = 1 cook_food_attack = 2 cook_food_function = 3 cook_food_defense = 4 cook_recipe = 5 class OpenStateCondType(Enum): open_state_cond_none = 0 open_state_cond_player_level = 1 open_state_cond_quest = 2 open_state_cond_parent_quest = 3 open_state_city_reputation_level = 4 open_state_offering_level = 5 class ActorBornRelativePosType(Enum): avatar = 0 main_intee = 1 npc = 2 avatar_new = 3 class DailyTaskActionType(Enum): daily_task_action_none = 0 daily_task_action_set_var = 1 daily_task_action_inc_var = 2 daily_task_action_dec_var = 3 daily_task_action_add_sure_pool = 4 daily_task_action_add_possible_pool = 5 class NewActivitySaleType(Enum): new_activity_sale_type_none = 0 new_activity_sale_type_weapon_upgrade = 1 class HuntingMonsterCreatePosType(Enum): hunting_pos_none = 0 hunting_pos_ground = 1 hunting_pos_shoal_water = 2 hunting_pos_snow_mountain = 3 class SceneType(Enum): scene_none = 0 scene_world = 1 scene_dungeon = 2 scene_room = 3 scene_home_world = 4 scene_home_room = 5 scene_activity = 6 class ExhibitionKeyType(Enum): exhibition_key_none = 0 exhibition_key_server = 1 exhibition_key_lua = 2 class RotAngleType(Enum): rot_angle_x = 0 rot_angle_y = 1 rot_angle_z = 2 class LocalizationAssetType(Enum): loc_default = 0 loc_image = 1 loc_text = 2 loc_subtitle = 3 loc_trophy_set_icon = 4 class MovePlatformDelayType(Enum): no_delay = 0 normal = 1 long = 2 class DecisionArchetype(Enum): general = 0 cicin = 1 animal = 2 dahaka = 3 animal_homeworld = 4 animal_fishable = 5 animal_ray = 6 player_auto = 100 class ActionTokenSourceType(Enum): source_invalid = -1 source_hit = 0 element_reaction = 1 low_effect_in_token_queue = 2 source_count = 3 class ChannellerSlabDifficulty(Enum): channeller_slab_difficulty_none = 0 channeller_slab_difficulty_primer = 1 channeller_slab_difficulty_normal = 2 channeller_slab_difficulty_hard = 3 channeller_slab_difficulty_expert = 4 class QuestSpecialShowType(Enum): special_show_none = 0 special_show_finish = 1 special_show_global_value_equal_to = 2 class RogueCreateGadgetType(Enum): rogue_gadget_type_none = 0 rogue_gadget_type_door = 1 rogue_gadget_type_normal_operator = 2 rogue_gadget_type_elite_operator = 3 rogue_gadget_type_spring_operator_reveal = 4 rogue_gadget_type_spring_operator_revive = 5 rogue_gadget_type_spring_operator_switch = 6 rogue_gadget_type_spring_store = 7 rogue_gadget_type_blast = 8 rogue_gadget_type_trap = 9 rogue_gadget_type_breakages = 10 rogue_gadget_type_ball = 11 rogue_gadget_type_guard = 12 class AbilityFormula(Enum): none = 0 dummy_throw_speed = 1 class MpPlayType(Enum): mp_play_none = 0 mp_play_crucible = 1 mp_play_aster = 2 mp_play_dragon_spine = 3 mp_play_water_sprite = 4 mp_play_winter_camp = 5 class MarkVisibilityType(Enum): none = 0 invisible = 1 around = 2 always = 3 class EntityMarkType(Enum): default = 0 show_effect = 1 class PileTag(Enum): none = 0 ground = 1 prop = 2 airflow = 3 spike = 4 wind_circle = 5 bubble = 6 class QteType(Enum): qte_type_none = 0 qte_type_any_step_fail_to_fail = 1 qte_type_never_fail = 2 class RogueDiaryBuffType(Enum): rogue_diary_buff_none = 0 rogue_diary_buff_r = 1 rogue_diary_buff_sr = 2 class AssocType(Enum): assoc_type_none = 0 assoc_type_mondstadt = 1 assoc_type_liyue = 2 assoc_type_mainactor = 3 assoc_type_fatui = 4 assoc_type_inazuma = 5 assoc_type_ranger = 6 class WidgetSkillReplaceType(Enum): a = 1 e = 2 q = 3 class DraftInviteType(Enum): draft_invite_none = 0 draft_invite_scene = 1 draft_invite_world = 2 class CrowdSpawnConditionType(Enum): inclusive = 0 exclusive = 1 class RandomQuestFilterType(Enum): rq_filter_none = 0 rq_filter_player_pos_ring = 1 rq_filter_npc = 2 rq_filter_player_level = 3 class DialogGroupSchemeType(Enum): quest = 0 free = 1 narrator = 2 blossom = 3 activity = 4 coop = 5 gadget = 6 class AvatarStageType(Enum): both = 0 current = 1 off_stage = 2 class KillSelfType(Enum): none = 0 normal = 1 disappear = 2 class TargetIndicatorType(Enum): default = 0 quest = 1 gadget = 2 task = 3 class TreeType(Enum): tree_type_birch = 1 tree_type_maple = 2 tree_type_pine = 3 tree_type_populus_euphratica = 4 tree_type_bamboo = 5 tree_type_energy_wood = 6 tree_type_cypress = 7 tree_type_firtree = 8 tree_type_cerasus = 9 tree_type_acer = 10 tree_type_cryptomeria = 11 tree_type_otogi = 12 class AttachPointTargetType(Enum): target = 0 self = 1 caster = 2 applier = 3 class ShowQuestGuideType(Enum): quest_guide_item_enable = 0 quest_guide_item_disable = 1 quest_guide_item_move_hide = 2 class QuestFishType(Enum): quest_fish_none = 0 quest_fish_material = 1 quest_fish_furniture = 2 class StrengthenPointType(Enum): strengthen_point_none = 0 strengthen_point_avatar = 1 strengthen_point_weapon = 2 strengthen_point_reliquary = 3 strengthen_point_talent = 4 class QteStepActionType(Enum): qte_step_action_none = 0 qte_step_action_success = 1 qte_step_action_fail = 2 qte_step_action_power_bar_value_change = 3 qte_step_action_power_bar_press_down = 4 qte_step_action_avatar_shake_head = 5 qte_step_action_play_audio = 6 qte_step_action_camera_move = 7 qte_step_action_emotion = 8 qte_step_action_cutscene_failed_black_screen = 9 qte_step_action_cutscene_time_scale_reset = 10 qte_step_action_cutscene_jump_point = 11 class DropNodeType(Enum): drop_node_leaf = 0 drop_node_tree = 1 class UseSkillType(Enum): none = 0 normal_attack = 1 skill = 2 ultimate_skill = 3 count = 4 class ConfigAiNerveTargetType(Enum): none = 0 monitor = 1 responser = 2 trigger_responser = 3 class GuideHasAvatarConType(Enum): id = 0 level = 1 class ConcernType(Enum): all_exclude_gwgo = 0 combat_exclude_gwgo = 1 all_avatars = 2 local_avatar = 3 local_team = 4 all_teams = 5 all_vehicle = 6 all_avatars_on_vehicle = 7 local_vehicle = 8 class ChallengeCondType(Enum): challenge_cond_none = 0 challenge_cond_in_time = 1 challenge_cond_all_time = 2 challenge_cond_kill_count = 3 challenge_cond_survive = 4 challenge_cond_time_inc = 5 challenge_cond_kill_fast = 6 challenge_cond_down_less = 7 challenge_cond_beaten_less = 8 challenge_cond_unnatural_count = 9 challenge_cond_frozen_less = 10 challenge_cond_kill_monster = 11 challenge_cond_trigger = 12 challenge_cond_guard_hp = 13 challenge_cond_time_dec = 14 challenge_cond_child_succ = 15 challenge_cond_child_fail = 16 challenge_cond_flight_get_badge = 17 challenge_cond_monster_damage_count = 18 challenge_cond_element_reaction_cont = 19 challenge_cond_freeze_enemy_in_time = 20 challenge_cond_crystal_element_reaction_count = 21 challenge_cond_sheild_absorb_damage_count = 22 challenge_cond_swirl_element_reaction_count = 23 challenge_cond_die_less = 24 class SectrSectorType(Enum): normal = 0 city = 1 navmesh = 2 class SceneAreaType(Enum): normal = 0 all = 1 other = 2 class QuestGuideLayer(Enum): quest_guide_layer_none = 0 quest_guide_layer_ui = 1 quest_guide_layer_scene = 2 class BanType(Enum): ban_invalid = 0 ban_transport = 1 ban_goto_scene = 2 ban_npc_interaction = 3 ban_goto_multiplayer = 4 class ActivityGroupLinkRewardType(Enum): none = 0 finish = 1 class ElementReactionSourceType(Enum): none = 0 being_hit = 1 modifier_add = 2 modifier_remove = 3 class RogueMonsterPoolDifficultyType(Enum): rogue_monster_difficulty_normal = 0 rogue_monster_difficulty_elite_easy = 1 rogue_monster_difficulty_elite_hard = 2 rogue_monster_difficulty_boss = 3 class SsaoMode(Enum): disable = 0 ssao = 1 hbao = 2 class ClimateType(Enum): climate_none = 0 climate_sunny = 1 climate_cloudy = 2 climate_rain = 3 climate_thunderstorm = 4 climate_snow = 5 climate_mist = 6 class NavmeshModeType(Enum): navmesh_mode_default = 0 navmesh_mode_polygon = 1 class ChangeFieldType(Enum): follow_ownner = 0 size_by_time = 1 class HomeWorldLimitShopCondType(Enum): homeworld_limit_shop_cond_type_none = 0 homeworld_limit_shop_cond_type_home_level = 1 homeworld_limit_shop_cond_type_quest_finish = 2 class HuntingRefreshCondType(Enum): hunting_refresh_cond_none = 0 hunting_refresh_cond_time = 1 hunting_refresh_cond_weather = 2 class InputEventType(Enum): invalid = 0 move_event = 1 change_view_event = 2 open_map_event = 3 open_character_event = 4 open_bag_event = 5 open_gacha_event = 6 open_chat_event = 7 open_paimon_event = 8 toggle_quest_book_event = 9 to_avatar1event = 10 to_avatar2event = 11 to_avatar3event = 12 to_avatar4event = 13 trigger_change_with_skill_event = 14 cancel_change_with_skill_event = 15 trigger_wheel_menu_event = 16 close_wheel_menu_event = 17 trigger_skill1event = 18 trigger_skill2event = 19 trigger_skill3event = 20 trigger_skill4event = 21 trigger_skill5event = 22 release_skill1event = 23 release_skill2event = 24 release_skill3event = 25 release_skill4event = 26 release_skill5event = 27 selecting_event = 28 cancel_selecting_event = 29 toggle_attack_mode_event = 30 enter_focus_mode_event = 31 exit_focus_mode_event = 32 talk_or_pick_event = 33 left_shoulder_event = 34 left_shoulder_release_event = 35 right_shoulder_event = 36 right_shoulder_release_event = 37 menu_back_event = 38 menu_backing_event = 39 menu_backing_cancel_event = 40 menu_confirm_event = 41 menu_confirming_event = 42 menu_confirming_cancel_event = 43 menu_left_event = 44 menu_left_pressing_event = 45 menu_left_just_released_event = 46 menu_up_event = 47 menu_right_event = 48 menu_down_event = 49 left_stick_left_event = 50 left_stick_right_event = 51 left_stick_up_event = 52 left_stick_down_event = 53 left_stick_event = 54 right_stick_event = 55 left_trigger_event = 56 left_trigger_release_event = 57 left_trigger_axis_event = 58 right_trigger_event = 59 right_trigger_release_event = 60 right_trigger_axis_event = 61 zoom_camera_event = 62 reset_camera_event = 63 enter_element_view_event = 64 exit_element_view_event = 65 toggle_slow_move_event = 66 toggle_slow_move_temp_event = 67 reset_temp_slow_move_event = 68 slip_event = 69 debug_menu_event = 70 left_stick_button_event = 71 right_stick_button_event = 72 quest_transport_event = 73 left_stick_vertical_event = 74 left_stick_horizontal_event = 75 left_stick_move_event = 76 right_stick_vertical_event = 77 right_stick_horizontal_event = 78 right_stick_move_event = 79 right_stick_left_event = 80 right_stick_right_event = 81 right_stick_up_event = 82 right_stick_down_event = 83 d_pad_up_event = 84 d_pad_right_event = 85 d_pad_down_event = 86 d_pad_left_event = 87 key_up_event = 88 key_down_event = 89 key_left_event = 90 key_right_event = 91 d_pad_up_pressing_event = 92 d_pad_right_pressing_event = 93 d_pad_down_pressing_event = 94 d_pad_left_pressing_event = 95 d_pad_up_release_event = 96 d_pad_right_release_event = 97 d_pad_down_release_event = 98 d_pad_left_release_event = 99 help_event = 100 multiplayer_event = 101 to_prev_intee_event = 102 to_next_intee_event = 103 joypad_toggle_intee_event = 104 open_notify_event = 105 open_dungeon_factor_event = 106 open_handbook_event = 107 track_quest_event = 108 open_activity_normal_event = 109 open_push_tips_event = 110 open_battle_pass_event = 111 to_avatar5event = 112 open_chat_joystick_event = 113 open_chat_cancel_joystick_event = 114 challenge_interrupt_event = 115 challenge_interrupt_joystick_event = 116 homeworld_create_custom_suite_joystick_event = 117 hide_event = 118 trigger_quick_use_event = 119 release_quick_use_event = 120 trigger_activity_skill_event = 121 release_activity_skill_event = 122 extera_select_up_event = 123 extera_select_down_event = 124 extera_select_left_event = 125 extera_select_right_event = 126 music_game_left_up_event = 127 music_game_left_right_event = 128 music_game_left_down_event = 129 music_game_left_left_event = 130 music_game_right_up_event = 131 music_game_right_right_event = 132 music_game_right_down_event = 133 music_game_right_left_event = 134 music_game_left_up_released_event = 135 music_game_left_right_released_event = 136 music_game_left_down_released_event = 137 music_game_left_left_released_event = 138 music_game_right_up_released_event = 139 music_game_right_right_released_event = 140 music_game_right_down_released_event = 141 music_game_right_left_released_event = 142 music_game_free1event = 143 music_game_free2event = 144 music_game_free3event = 145 music_game_free4event = 146 music_game_free5event = 147 music_game_free6event = 148 music_game_free7event = 149 music_game_free8event = 150 music_game_free9event = 151 music_game_free10event = 152 music_game_free11event = 153 music_game_free12event = 154 music_game_free13event = 155 music_game_free14event = 156 music_game_free15event = 157 music_game_free16event = 158 music_game_free17event = 159 music_game_free18event = 160 music_game_free19event = 161 music_game_free20event = 162 music_game_free21event = 163 menu_next_event = 164 f1event = 165 f2event = 166 f3event = 167 return_event = 168 open_homeworld_handbook_event = 169 open_homeworld_editor_event = 170 open_team_page_event = 171 open_friend_page_event = 172 object_turn_up_event = 173 object_turn_down_event = 174 object_turn_left_event = 175 object_turn_right_event = 176 camera_move_up_pressed_event = 177 camera_move_up_released_event = 178 camera_move_down_pressed_event = 179 camera_move_down_released_event = 180 custom_level_switch_float_mode_event = 181 custom_level_deploy_confirm_event = 182 arrow_up_event = 183 arrow_down_event = 184 arrow_left_event = 185 arrow_right_event = 186 left_control_event = 187 left_control_released_event = 188 space_event = 189 space_released_event = 190 undo_event = 191 save_event = 192 object_turn_up_release_event = 193 object_turn_down_release_event = 194 object_turn_left_release_event = 195 object_turn_right_release_event = 196 object_turn_clockwise_event = 197 object_turn_anti_clockwise_event = 198 object_turn_clockwise_release_event = 199 object_turn_anti_clockwise_release_event = 200 open_menu_event = 201 open_menu_release_event = 202 count = 203 class ExploreType(Enum): explore_none = 0 explore_chest = 1 explore_temple = 2 explore_gather = 3 class GivingType(Enum): giving_type_none = 0 giving_type_quest = 1 giving_type_gadget = 2 class ConfigAiCombatSkillType(Enum): unclassified = 0 melee_attack = 1 ranged_attack = 2 class FireworksLaunchParamType(Enum): fireworks_launch_param_none = 0 fireworks_launch_param_repeat = 1 fireworks_launch_param_inteval = 2 fireworks_launch_param_delay = 3 fireworks_launch_param_round_inteval = 4 class BoardEventType(Enum): board_event_none = 0 board_event_kill_monster = 1 board_event_game = 101 board_event_gather = 102 board_event_accelerate = 104 board_event_use_item = 105 board_event_change_avatar = 106 board_event_skill = 107 board_event_region = 108 class ReputationEntranceCondType(Enum): reputation_entrance_cond_none = 0 reputation_entrance_cond_reputation_level = 1 reputation_entrance_cond_player_level = 2 reputation_entrance_cond_quest = 3 class RegionSearchType(Enum): region_search_type_none = 0 region_search_type_activity = 1 class EffectType(Enum): wind_effect = 0 class HitBoxType(Enum): normal = 0 head = 1 class RogueGadgetDirType(Enum): rogue_gadget_rot_up = 0 rogue_gadget_rot_down = 1 rogue_gadget_rot_left = 2 rogue_gadget_rot_right = 3 class OpResponder(Enum): caster = 0 receiver = 1 free_agent = 2 effect = 3 class FollowAttachOccupyPriority(Enum): follow_pet = 10 theme_play = 50 quest_event = 80 activity_event = 90 quest_blank = 100 class LookAtTargetType(Enum): npc = 0 camera = 1 none = 2 class PropType(Enum): prop_none = 0 prop_exp = 1001 prop_break_level = 1002 prop_satiation_val = 1003 prop_satiation_penalty_time = 1004 prop_gear_start_val = 2001 prop_gear_stop_val = 2002 prop_level = 4001 prop_last_change_avatar_time = 10001 prop_max_spring_volume = 10002 prop_cur_spring_volume = 10003 prop_is_spring_auto_use = 10004 prop_spring_auto_use_percent = 10005 prop_is_flyable = 10006 prop_is_weather_locked = 10007 prop_is_game_time_locked = 10008 prop_is_transferable = 10009 prop_max_stamina = 10010 prop_cur_persist_stamina = 10011 prop_cur_temporary_stamina = 10012 prop_player_level = 10013 prop_player_exp = 10014 prop_player_hcoin = 10015 prop_player_scoin = 10016 prop_player_mp_setting_type = 10017 prop_is_mp_mode_available = 10018 prop_player_world_level = 10019 prop_player_resin = 10020 prop_player_wait_sub_hcoin = 10022 prop_player_wait_sub_scoin = 10023 prop_is_only_mp_with_ps_player = 10024 prop_player_mcoin = 10025 prop_player_wait_sub_mcoin = 10026 prop_player_legendary_key = 10027 prop_is_has_first_share = 10028 prop_player_forge_point = 10029 prop_cur_climate_meter = 10035 prop_cur_climate_type = 10036 prop_cur_climate_area_id = 10037 prop_cur_climate_area_climate_type = 10038 prop_player_world_level_limit = 10039 prop_player_world_level_adjust_cd = 10040 prop_player_legendary_daily_task_num = 10041 prop_player_home_coin = 10042 prop_player_wait_sub_home_coin = 10043 prop_is_auto_unlock_specific_equip = 10044 class TalkRoleType(Enum): talk_role_none = 0 talk_role_npc = 1 talk_role_player = 2 talk_role_mate_avatar = 3 talk_role_gadget = 4 talk_role_black_screen = 5 talk_role_need_click_black_screen = 6 talk_role_avatar_npc = 7 class StateCameraType(Enum): normal_move = 0 combat_normal = 1 combat_be_hit = 2 class QState(Enum): invalid = -1 accepted = 0 updated = 1 finished = 2 failed = 3 class GadgetInteractItemType(Enum): default = 0 regional_play = 1 class DoActionByDamageReceivedParamType(Enum): hp_max_percent = 0 class LightLevel(Enum): low = 0 middle = 1 high = 2 invalid = 3 class VolatileType(Enum): default = 0 topmost = 1 high = 2 middle = 3 low = 4 very_low = 5 false = 6 class ExhibitionScoreType(Enum): exhibition_score_none = 0 exhibition_score_value = 1 exhibition_score_display_param_factor = 2 class GuideNavigationCheckType(Enum): none = 0 open = 1 close = 2 class FireworksReformSkillType(Enum): fireworks_reform_skill_none = 0 fireworks_reform_skill_general = 1 fireworks_reform_skill_instable = 2 fireworks_reform_skill_adjacent = 3 class GearType(Enum): none = 0 ray = 1 spray = 2 wall = 3 class TextMapPlatformType(Enum): default = 0 ios = 1 pc = 2 android = 3 ps4 = 4 switch = 5 ps5 = 6 class ProjectionGameGuideInputMode(Enum): touch = 0 mouse = 1 joypad = 2 class ColliderTriggerType(Enum): trigger_once = 0 trigger_no_repeat = 1 trigger_always = 2 class TargetRegisterType(Enum): register_once = 0 register_always = 1 class ViewCacheType(Enum): lru_cached = 0 always_cached = 1 dont_cache = 2 class RoutineActionype(Enum): routine_action_none = 0 class MiracleTag(Enum): tag_none = 0 tag_fire = 1 tag_test_one = 2 tag_test_two = 3 tag_scoin = 4 tag_avatar_exp = 5 tag_weapon_exp = 6 tag_avatar_promote = 7 tag_weapon_promote = 8 tag_skill_book = 9 class GlobalValueChangeType(Enum): add = 0 set = 1 class ActivityGachaTargetType(Enum): target_type_none = 0 target_type_gather = 1 target_type_elem = 2 target_type_monster = 3 class RegionalPlayVarType(Enum): michiae_matsuri_dark_pressure = 2500 michiae_matsuri_crystal_energy = 2501 light_stone_energy = 2600 class DataEntityType(Enum): data_entity_none = 0 data_entity_monster = 1 data_entity_gadget = 2 class ChessCardTag(Enum): card_tag_none = 0 card_tag_water = 1 card_tag_fire = 2 card_tag_ice = 3 card_tag_wind = 4 card_tag_electric = 5 card_tag_physics = 6 card_tag_help = 7 card_tag_other = 8 class CustomGadgetNodeSlotType(Enum): default = 0 furniture = 1 class TriggerFlag(Enum): none = 0 no_revive_region = 1 dead_region = 2 return_region = 3 camera_scene_look = 4 level_ability = 5 audio_event = 6 global_value = 7 teleport = 8 teleport_without_paimon_reminder = 9 teleport_v2 = 10 class ModifierTag(Enum): none = 0 corruption = 1 class PerfOptionTextType(Enum): grade = 0 literally = 1 text_map = 2 class PointLocation(Enum): point_ground = 0 point_air = 1 class GadgetType(Enum): gadget_none = 0 gadget_world_chect = 1 gadget_dungeon_secret_chest = 2 gadget_dungeon_pass_chest = 3 class BillboardOffsetType(Enum): normal = 0 character = 1 class CheckboardType(Enum): none = 0 msaa2x = 1 line_half = 2 class ShopRecommendTabType(Enum): recommend_one = 0 recommend_col = 1 recommend_item = 2 recommend_jump = 3 recommend_package = 4 class NewActivityCondType(Enum): new_activity_cond_none = 0 new_activity_cond_time_greater = 1 new_activity_cond_time_less = 2 new_activity_cond_player_level_greater = 3 new_activity_cond_quest_finish = 4 new_activity_cond_finish_talk = 5 new_activity_cond_create_npc = 6 new_activity_cond_not_finish_talk = 7 new_activity_cond_salesman_can_deliver = 8 new_activity_cond_salesman_can_get_reward = 9 new_activity_cond_aster_mid_camp_refreshable = 10 new_activity_cond_finish_watcher = 11 new_activity_cond_days_great_equal = 12 new_activity_cond_days_less = 13 new_activity_cond_player_level_great_equal = 14 new_activity_cond_scene_mp_play_activated = 15 new_activity_cond_sea_lamp_popularit = 16 new_activity_cond_sea_lamp_phase = 17 new_activity_cond_mechanicus_open = 18 new_activity_cond_finish_region_search_logic = 19 new_activity_cond_finish_region_search = 20 new_activity_cond_finish_water_spirit_phase = 21 new_activity_cond_finish_find_hilichurl_level_equal = 22 new_activity_cond_finish_find_hilichurl_level_less = 23 new_activity_cond_finish_channeller_slab_oneoff_dungeon_in_stage = 24 new_activity_cond_finish_channeller_slab_any_oneoff_dungeon = 25 new_activity_cond_sepcified_activity_end = 26 new_activity_cond_unlocked_all_listed_scene_points = 27 new_activity_cond_treasure_map_bonus_spot_got_any_fragment = 28 new_activity_cond_item_count_greater = 29 new_activity_cond_quest_global_var_greater = 30 new_activity_cond_quest_global_var_less = 31 new_activity_cond_quest_global_var_equal = 32 new_activity_cond_finish_dig_activity = 33 new_activity_cond_group_bundle_finished = 34 new_activity_cond_plant_flower_can_deliver = 35 new_activity_cond_luna_rite_atmosphere = 36 new_activity_cond_finish_hachi_stage = 37 new_activity_cond_finish_channeller_slab_any_stage_all_camp = 38 new_activity_cond_finish_channeller_slab_appointed_stage_all_camp = 39 new_activity_cond_hachi_finish_stealth_stage_equal = 40 new_activity_cond_hachi_finish_battle_stage_equal = 41 new_activity_cond_finish_salvage_stage = 42 new_activity_cond_finish_bartender_level = 43 new_activity_cond_finish_potion_any_level = 44 new_activity_cond_finish_custom_dungeon_official = 45 new_activity_cond_quest_finish_allow_quick_open = 46 new_activity_cond_finish_photo_pos_id = 47 new_activity_cond_finish_music_game_all_level = 48 new_activity_cond_current_luminance_stone_challenge_stage = 49 new_activity_cond_luminance_stone_challenge_final_gallery_complete = 50 new_activity_cond_offering_level_great_equal = 51 new_activity_cond_luminance_stone_challenge_stage_great_equal = 52 new_activity_cond_finish_any_arena_challenge_level = 53 new_activity_cond_gacha_can_create_robot = 54 class ArithType(Enum): arith_none = 0 arith_add = 1 arith_multi = 2 arith_sub = 3 arith_divide = 4 class ParticleShapeType(Enum): volume = 0 edge = 1 shell = 2 class ConfigGadgetConsoleOperationType(Enum): x = 0 y = 1 z = 2 class ChallengeEventMarkType(Enum): challenge_event_none = 0 flight_time = 1 flight_gather_point = 2 summer_time_sprint_boat_time = 3 summer_time_sprint_boat_gather_point = 4 class RelationalOperator(Enum): greater = 0 greater_or_equal = 1 equal = 2 lesser = 3 lesser_or_equal = 4 class InterPriorityType(Enum): override = 0 insert = 1 additive = 2 free_to_do = 3 class InputActionGroupType(Enum): all = 0 gameplay = 1 menu = 2 class ControlPartDoOnUnEnabled(Enum): stay = 0 to_forward_immediately = 1 rotate_to_forward = 2 class LoadingAreaType(Enum): loading_area_none = 0 loading_area_city = 1 loading_area_outdoor = 2 class PersonalLineActivityFeature(Enum): legend_quest = 0 no_legend_quest = 1 class DieStateFlag(Enum): none = 0 frozen_to_death = 1 burning_to_ashes = 2 die_fall = 3 die_drawn = 4 die_abyss = 5 broken = 6 petrified_to_death = 7 class InterruptButtonType(Enum): interrupt_button_type_none = 0 interrupt_button_type_host = 1 interrupt_button_type_all = 2 class MonsterType(Enum): monster_none = 0 monster_ordinary = 1 monster_boss = 2 monster_env_animal = 3 monster_little_monster = 4 monster_fish = 5 class RogueDiaryResourceType(Enum): rogue_diary_get_fight = 0 rogue_diary_get_challenge = 1 rogue_diary_get_boss = 2 rogue_diary_use_reroll = 3 rogue_diary_get_buycard = 4 rogue_diary_get_revive = 5 class ExhibitionSeriesType(Enum): exhibition_series_none = 0 exhibition_series_activity = 1 exhibition_series_dungeon = 2 class InvestigationType(Enum): investigation_adventure = 0 investigation_homeworld = 1 investigation_edcation = 2 class CreateSeverGadgetOpType(Enum): none = 1 retract = 2 retract_and_create = 3 class CreateGadgetMixinType(Enum): only_origin_owner = 0 only_sub_owner = 1 both_owner = 2 class RoutineCondType(Enum): routine_cond_none = 0 routine_cond_quest_finish = 1 class CrystalLinkDifficultyType(Enum): crystal_link_difficulty_easy = 0 crystal_link_difficulty_mid = 1 crystal_link_difficulty_hard = 2 class DieFlag(Enum): alive = 0 normal = 1 drowned = 2 in_air = 3 retreat = 4 fall = 5 class ExclusiveRuleType(Enum): exclusive_rule_none = 0 exclusive_rule_weapon_affix = 1 exclusive_rule_flycloak = 2 class EffigyCondition(Enum): effigy_condition_none = 0 effigy_condition_time_limit = 1 effigy_condition_level_config = 2 effigy_condition_monster_config = 3 class TemplateReminderStyleType(Enum): normal = 0 message_dialog = 1 dialog_box = 2 message_push_page_first_time = 3 class WeaponMaterialType(Enum): weapon_material_none = 0 class CaptureCodexShowType(Enum): capture_codex_show_type_none = 0 capture_codex_show_type_not_show = 1 capture_codex_show_type_capture_animal = 2 class QuestContentType(Enum): quest_content_none = 0 quest_content_kill_monster = 1 quest_content_complete_talk = 2 quest_content_monster_die = 3 quest_content_finish_plot = 4 quest_content_obtain_item = 5 quest_content_trigger_fire = 6 quest_content_clear_group_monster = 7 quest_content_not_finish_plot = 8 quest_content_enter_dungeon = 9 quest_content_enter_my_world = 10 quest_content_finish_dungeon = 11 quest_content_destroy_gadget = 12 quest_content_obtain_material_with_subtype = 13 quest_content_nick_name = 14 quest_content_worktop_select = 15 quest_content_seal_battle_result = 16 quest_content_enter_room = 17 quest_content_game_time_tick = 18 quest_content_fail_dungeon = 19 quest_content_lua_notify = 20 quest_content_team_dead = 21 quest_content_complete_any_talk = 22 quest_content_unlock_trans_point = 23 quest_content_add_quest_progress = 24 quest_content_interact_gadget = 25 quest_content_daily_task_comp_finish = 26 quest_content_finish_item_giving = 27 quest_content_skill = 107 quest_content_city_level_up = 109 quest_content_pattern_group_clear_monster = 110 quest_content_item_less_than = 111 quest_content_player_level_up = 112 quest_content_dungeon_open_statue = 113 quest_content_unlock_area = 114 quest_content_open_chest_with_gadget_id = 115 quest_content_unlock_trans_point_with_type = 116 quest_content_finish_daily_dungeon = 117 quest_content_finish_weekly_dungeon = 118 quest_content_quest_var_equal = 119 quest_content_quest_var_greater = 120 quest_content_quest_var_less = 121 quest_content_obtain_various_item = 122 quest_content_finish_tower_level = 123 quest_content_bargain_succ = 124 quest_content_bargain_fail = 125 quest_content_item_less_than_bargain = 126 quest_content_activity_trigger_failed = 127 quest_content_main_coop_enter_save_point = 128 quest_content_any_manual_transport = 129 quest_content_use_item = 130 quest_content_main_coop_enter_any_save_point = 131 quest_content_enter_my_home_world = 132 quest_content_enter_my_world_scene = 133 quest_content_time_var_gt_eq = 134 quest_content_time_var_pass_day = 135 quest_content_quest_state_equal = 136 quest_content_quest_state_not_equal = 137 quest_content_unlocked_recipe = 138 quest_content_not_unlocked_recipe = 139 quest_content_fishing_succ = 140 quest_content_enter_rogue_dungeon = 141 quest_content_use_widget = 142 quest_content_capture_succ = 143 quest_content_capture_use_capturetag_list = 144 quest_content_capture_use_material_list = 145 quest_content_enter_vehicle = 147 quest_content_scene_level_tag_eq = 148 quest_content_leave_scene = 149 quest_content_leave_scene_range = 150 quest_content_irodori_finish_flower_combination = 151 quest_content_irodori_poetry_reach_min_progress = 152 quest_content_irodori_poetry_finish_fill_poetry = 153 quest_content_activity_trigger_update = 154 quest_content_gadget_state_change = 155 class BrickType(Enum): brick_type_none = 0 brick_type_coin = 1 brick_type_finish = 2 class ReliquaryMainAffixName(Enum): reliquary_main_affix_none = 0 reliquary_main_affix_tough = 1 reliquary_main_affix_strong = 2 reliquary_main_affix_ruthless = 3 reliquary_main_affix_fatal = 4 reliquary_main_affix_glory = 5 reliquary_main_affix_eminence = 6 reliquary_main_affix_exultation = 7 reliquary_main_affix_cruel = 8 reliquary_main_affix_holiness = 9 reliquary_main_affix_fierce = 10 reliquary_main_affix_wisdom = 11 reliquary_main_affix_concentration = 12 class CombatEndType(Enum): combat_end_none = 0 combat_end_tower_half_level_end = 1 combat_end_tower_level_end = 2 combat_end_dungeon_settle = 3 combat_end_crystal_link_half_level_end = 4 combat_end_count = 5 class WeaponType(Enum): weapon_none = 0 weapon_sword_one_hand = 1 weapon_crossbow = 2 weapon_staff = 3 weapon_double_dagger = 4 weapon_katana = 5 weapon_shuriken = 6 weapon_stick = 7 weapon_spear = 8 weapon_shield_small = 9 weapon_catalyst = 10 weapon_claymore = 11 weapon_bow = 12 weapon_pole = 13 class EntityTriggerType(Enum): common = 0 one_way = 1 class BoredActionType(Enum): bored_action_none = 0 bored_action_create_monster = 1 bored_action_ambush = 2 bored_action_enhance_gather = 3 class OverflowTransformType(Enum): overflow_transform_none = 0 overflow_transform_player_exp = 1 class MultiPositionType(Enum): single_source = 0 multi_sources = 1 multi_directions = 2 class FlowSuiteOperatePolicy(Enum): flow_suite_op_default = 0 flow_suite_op_complete = 1 class TalkMarkType(Enum): talk_mark_none = 0 talk_mark_common = 1 talk_mark_hide = 2 class HasShieldType(Enum): elite_shield = 0 element_shield = 1 global_shield = 2 all = 3 class ChessCardEffectType(Enum): chess_card_effect_default = 0 chess_card_effect_set_sgv = 1 chess_card_effect_mod_cost = 2 chess_card_effect_mod_refund = 3 chess_card_effect_set_home_hp = 4 chess_card_effect_add_home_hp = 5 chess_card_effect_add_kill_points = 6 chess_card_effect_mod_kill_points = 7 chess_card_effect_add_gear_num = 8 chess_card_effect_kill_gears = 9 chess_card_effect_grant_points = 10 chess_passive_aura_bonus_points = 11 chess_passive_aura_sgv = 12 chess_card_effect_random_remove = 13 chess_card_effect_points_on_round_end = 14 chess_card_effect_sgv_pick_card_lte = 15 chess_card_effect_mod_card_cost = 16 chess_card_effect_cards_type_count_no_cost = 17 chess_card_effect_mod_candidate_cards = 18 chess_card_effect_mod_quality_prob = 19 chess_card_effect_free_card_refresh = 20 chess_card_effect_mod_refresh_cost = 21 chess_card_effect_cards_count_stack_sgv = 22 chess_card_effect_points_stack_sgv = 23 chess_card_effect_card_type_stack_sgv = 24 chess_card_effect_card_type_force_curse = 25 class StoryCameraTargetType(Enum): absolute = 0 to_intee = 1 to_inter = 2 to_mid = 3 relative_to_inter = 4 relative_to_target_entity = 5 relative_to_intee_forward = 6 relative_to_inter_forward = 7 relative_to_multi_target_entity = 8 relative_to_intee = 9 other = 10 class ActivityBannerType(Enum): activity_banner_default = 0 activity_banner_monster = 1 activity_banner_chapter = 2 class ChallengeRecordType(Enum): challenge_record_type_none = 0 challenge_record_type_in_time = 1 class GuideNavigationType(Enum): none = 0 task = 1 quest = 2 class ShadowQuality(Enum): very_low = 0 low = 1 medium = 2 high = 3 very_high = 4 class RegionalPlayType(Enum): michiae_matsuri = 2500 light_stone = 2600 class ActionBtnType(Enum): sprint = 0 jump = 1 slip = 2 attack_mode = 3 skill1 = 4 skill2 = 5 skill3 = 6 skill4 = 7 skill5 = 8 skill_left = 9 squat = 10 roll = 11 charge = 12 quick_use = 13 vehicle_off = 14 class EventType(Enum): event_none = 0 event_any_monster_die = 1 event_any_gadget_die = 2 event_variable_change = 3 event_enter_region = 4 event_leave_region = 5 event_gadget_create = 6 event_gadget_state_change = 7 event_dungeon_settle = 8 event_select_option = 9 event_client_execute = 10 event_any_monster_live = 11 event_specific_monster_hp_change = 12 event_city_levelup_unlock_dungeon_entry = 13 event_dungeon_broadcast_ontimer = 14 event_timer_event = 15 event_challenge_success = 16 event_challenge_fail = 17 event_seal_battle_begin = 18 event_seal_battle_end = 19 event_gather = 20 event_quest_finish = 21 event_monster_battle = 22 event_city_levelup = 23 event_cutscene_end = 24 event_avatar_near_platform = 25 event_platform_reach_point = 26 event_unlock_trans_point = 27 event_quest_start = 28 event_group_load = 29 event_group_will_unload = 30 event_group_will_refresh = 31 event_group_refresh = 32 event_dungeon_reward_get = 33 event_specific_gadget_hp_change = 34 event_monster_tide_over = 35 event_monster_tide_create = 36 event_monster_tide_die = 37 event_sealamp_phase_change = 38 event_blossom_progress_finish = 39 event_blossom_chest_die = 40 event_gadget_play_start = 41 event_gadget_play_start_cd = 42 event_gadget_play_stop = 43 event_gadget_lua_notify = 44 event_mp_play_prepare = 45 event_mp_play_battle = 46 event_mp_play_prepare_interrupt = 47 event_select_difficulty = 48 event_scene_mp_play_battle_state = 49 event_scene_mp_play_battle_stage_change = 50 event_scene_mp_play_battle_result = 51 event_seal_battle_progress_decrease = 52 event_general_reward_die = 53 event_scene_mp_play_battle_interrupt = 54 event_monster_die_before_leave_scene = 55 event_scene_mp_play_open = 56 event_offering_levelup = 57 event_dungeon_revive = 58 event_scene_mp_play_all_avatar_die = 59 event_dungeon_all_avatar_die = 60 event_general_reward_taken = 61 event_platform_reach_arraypoint = 62 event_scene_multistage_play_stage_end = 63 event_scene_multistage_play_end_stage_req = 64 event_mechanicus_picked_card = 65 event_pool_monster_tide_over = 66 event_pool_monster_tide_create = 67 event_pool_monster_tide_die = 68 event_dungeon_avatar_slip_die = 69 event_gallery_start = 70 event_gallery_stop = 71 event_time_axis_pass = 72 event_fleur_fair_dungeon_all_player_enter = 73 event_gadgettalk_done = 74 event_set_game_time = 75 event_hide_and_seek_player_quit = 76 event_avatar_die = 77 event_scene_multistage_play_stage_start = 78 event_gallery_progress_pass = 79 event_gallery_progress_empty = 80 event_gallery_progress_full = 81 event_hunting_finish_final = 82 event_use_widget_toy_fox_camera = 83 event_luna_rite_sacrifice = 84 event_sumo_switch_team_event = 85 event_fishing_start = 86 event_fishing_stop = 87 event_fishing_qte_finish = 88 event_fishing_timeout_flee = 89 event_rogue_cell_state_change = 90 event_rogue_cell_construct = 91 event_rogue_cell_finish_select_card = 92 event_any_monster_capture = 93 event_activity_interact_gadget = 94 event_challenge_pause = 95 event_level_tag_change = 96 event_custom_dungeon_start = 97 event_custom_dungeon_restart = 98 event_custom_dungeon_reactive = 99 event_custom_dungeon_out_stuck = 100 event_custom_dungeon_exit_try = 101 event_custom_dungeon_official_restart = 102 event_any_monster_capture_and_disappear = 103 event_michiae_interact = 104 event_select_uiinteract = 105 event_lua_notify = 106 event_photo_finish = 107 event_irodori_master_ready = 108 event_rogue_start_fight = 109 event_rogue_creage_fight_gadget = 110 event_rogue_creage_repair_gadget = 111 event_rogue_open_access = 112 event_gadget_giving_finished = 113 event_observation_point_notify = 114 event_gadget_giving_takeback = 115 event_echo_shell_interact = 116 event_platform_arrival = 2701 event_player_back_gallery_revive_point = 2800 event_gallery_cannot_start_after_countdown = 2801 class AbilityCameraShotType(Enum): avatar = 0 level = 1 class ProjectionGameGuideFinishType(Enum): free_rotation_xy = 0 free_rotation_z = 1 switch = 2 class GrassQualityLevel(Enum): very_low = 1 low = 2 middle = 3 high = 4 very_high = 5 ultra_high = 6 num = 8 class AvatarFilterType(Enum): avatar_filter_none = 0 avatar_filter_avatar_id = 1 avatar_filter_weapon_type = 2 avatar_filter_element_type = 3 class DropElemControlType(Enum): all = 0 none = 1 class AnimalCodexType(Enum): codex_animal = 0 codex_monster = 1 class AnimalCodexSubType(Enum): codex_subtype_elemental = 0 codex_subtype_hilichurl = 1 codex_subtype_abyss = 2 codex_subtype_fatui = 3 codex_subtype_automatron = 4 codex_subtype_human = 5 codex_subtype_beast = 6 codex_subtype_boss = 7 codex_subtype_aviary = 8 codex_subtype_animal = 9 codex_subtype_fish = 10 codex_subtype_critter = 11 class MusicGameParam(Enum): none = 0 time = 1 scene_id = 2 area_id = 4 weather = 8 enemy_count = 16 enemy_distance = 32 quest_id_list = 64 last_user_cue = 128 random = 256 class GuideGeneralConditionType(Enum): none = 0 music_game_v3button = 1 music_game_v3slider = 2 reward_add_resin = 3 class ShopRecommendTagType(Enum): shop_recommend_tag_type_none = 0 shop_recommend_tag_type_limittime = 1 shop_recommend_tag_type_discount = 2 shop_recommend_tag_type_new = 3 class InteractCondType(Enum): interact_cond_none = 0 interact_cond_widget_on = 1 interact_cond_has_item = 2 interact_cond_regional_play_var_greater_than = 3 interact_cond_offering_level = 4 class TutorialDetailType(Enum): tut_default = 0 tut_full_screen = 1 class ModifierTimeScale(Enum): owner = 0 level = 1 class ElemBallTriggerType(Enum): none = 0 in_rain = 1 after_rain = 2 in_snow = 3 in_storm = 4 class GuideItemType(Enum): normal = 0 weapon = 1 relic = 2 any = 3 material = 4 class NeuronMixinRemoveOperatorType(Enum): one_by_one = 0 first_finish_delete = 1 all_finish_delete = 2 class ParentQuestState(Enum): parent_quest_state_none = 0 parent_quest_state_finished = 1 parent_quest_state_failed = 2 parent_quest_state_canceled = 3 class TrialFetterConditionType(Enum): trial_fetter_condition_complete_sub_mission = 0 trial_fetter_condition_level = 1 class RocketJumpType(Enum): xiao_ult = 0 klee_mine_explode = 1 gear_spring = 2 dungeon_jump = 3 itto_gang_plank = 4 max_value = 5 class AbilityGroupSourceType(Enum): ability_group_source_none = 0 ability_group_source_challenge = 1 ability_group_source_quest = 2 ability_group_source_activity = 3 ability_group_source_hunting = 4 ability_group_source_watcher = 5 ability_group_source_avatar_skill_depot = 6 ability_group_source_gallery = 7 ability_group_source_widget = 8 ability_group_source_fishing = 9 class MoonfinTrialActivityLevelType(Enum): moonfin_trial_activity_level_type_quest = 0 moonfin_trial_activity_level_type_challenge_total = 1 moonfin_trial_activity_level_type_challenge_specific = 2 moonfin_trial_activity_level_type_challenge_continuous = 3 moonfin_trial_activity_level_type_special_fish = 4 class SettleUiType(Enum): settle_ui_al_ways_show = 0 settle_ui_on_success = 1 settle_ui_on_fail = 2 settle_ui_never_show = 3 class RouteType(Enum): one_way = 0 reciprocate = 1 loop = 2 class ChestShowUiRemind(Enum): none = 0 normal = 1 all_show = 2 class AreaTerrainType(Enum): area_terrain_none = 0 area_terrain_city = 1 area_terrain_outdoor = 2 class AsterPhase(Enum): aster_phase_none = 0 aster_phase_little = 1 aster_phase_mid = 2 aster_phase_large = 3 class WorldType(Enum): world_none = 0 world_player = 1 world_home = 2 class IrodoriChessCardQualityType(Enum): irodori_card_quality_noraml = 0 irodori_card_quality_good = 1 irodori_card_quality_percect = 2 class SceneSubType(Enum): scene_sub_type_none = 0 scene_sub_type_persistent_dungeon = 1 class LevelBuffSpecial(Enum): none = 0 witch_time_duration_scaled_by_evaded_attack = 1 infinite_duration = 2 class InteractActionType(Enum): interact_action_none = 0 interact_action_state = 1 interact_action_set_gadget_chain_buff = 2 interact_action_unlock_special_transport_point = 3 interact_action_consume_regional_play_var = 4 class WidgetBusinessType(Enum): resident = 1 activity = 2 class ComponentTag(Enum): ability = 0 ai = 1 avatar_ai = 2 avatar_ai_no_combat = 3 combat = 4 gadget_combat = 5 bullet_combat = 6 gadget_collided_combat = 7 scene_prop_combat = 8 scene_grass_water_combat = 9 character_combat = 10 avatar_combat = 11 monster_combat = 12 has_equip = 13 has_avatar_equip = 14 has_monster_equip = 15 level = 16 paimon = 17 scene_prop = 18 team = 19 has_emotion = 20 has_billboard = 21 has_collision = 22 has_emoji_bubble = 23 has_face_animation = 24 has_move = 25 has_bullet_move = 26 has_humanoid_move = 27 has_non_humanoid_move = 28 has_animator_move = 29 has_npc_move = 30 has_simple_move = 31 has_rigid_body_move = 32 class ExclusivePlatformType(Enum): exclusive_none = 0 exclusive_psn = 1 class QteStepButtonInputType(Enum): qte_step_button_input_jump = 0 qte_step_button_input_left_move = 1 class TextShowPlace(Enum): text_show_none = 0 class KeyboardType(Enum): invalid = 0 de = 1031 en = 1033 fr = 1036 class ConfigWeatherEffectControlType(Enum): set_emit_offset_pos = 0 set_emit_play_speed = 1 set_emit_play_speed_with_lerp = 2 set_velocity_multiplier = 3 set_emit_position = 4 class MechanicusCardType(Enum): mechanicus_card_none = 0 mechanicus_card_buff = 1 mechanicus_card_curse = 2 mechanicus_card_challenge = 3 class CcdType(Enum): only_high_speed = 0 always = 1 never = 2 class BattleFervorStateIdTriggerType(Enum): enter = 1 enter_and_stay = 3 class CreaterDir(Enum): down = 0 back = 1 class GadgetUiItemGroupShowCondType(Enum): none = 0 min_distance = 1 class CodexQuestItemType(Enum): text_center = 1 text_left = 2 text_right = 3 single_dialog = 4 multi_dialog = 5 single_dialog_gender = 6 multi_dialog_gender = 7 class MarkVisibleType(Enum): none = 0 always = 1 around = 2 condition_only = 3 other = 4 class BodyMaterialType(Enum): all = 0 body = 1 hair = 2 face = 3 weapon = 4 arm = 5 in_valid = 999 class HpBarStyle(Enum): auto = 0 elite = 1 boss = 2 friendly = 3 element_charge = 4 boss_compress = 5 class ProudSkillType(Enum): proud_skill_none = 0 proud_skill_core = 1 proud_skill_inherent = 2 proud_skill_active = 3 class TriggerMode(Enum): inside = 0 outside = 1 class PlayModeType(Enum): normal = 0 sneak = 1 dvalin_s01fly_state = 2 bomber = 3 find_cat = 4 wild_sneak = 5 gliding_challenge_state = 6 look_at_camera_state = 7 fleur_fair_fall = 8 endora_state = 9 fleur_fair_balloon = 10 hide_and_seek = 11 hide_and_seek_ghost = 12 vehicle_skiff = 13 bounce_conjuring = 14 activity_aim_state = 15 electric_core_state = 16 fishing = 17 avatar_trans_move = 18 avatar_trans_move_no_jump = 19 tail = 20 winter_camp_race = 21 bartender = 22 ugc_forbid_skill = 23 blocking = 24 black_mud = 25 class H5activityCondType(Enum): h5_activity_cond_none = 0 h5_activity_cond_player_level = 1 h5_activity_cond_register_time_great_equal = 2 h5_activity_cond_day_count_great_equal = 3 class CompareProperty(Enum): hp_ratio = 0 class CanBeModifiedBy(Enum): none = 0 owner = 1 origin_owner = 2 class TriggerWeatherType(Enum): area = 0 weather = 1 skill = 2 class LuaCallType(Enum): gadget = 0 owner_gadegt = 1 from_group = 2 owner_from_group = 3 specific_group = 4 cur_scene_play = 5 cur_challenge_group = 6 cur_gallery_control_group = 7 cur_rogue_boss_group = 8 ability_group_source_group = 9 class MichiaeMatsuriRadarMarkType(Enum): michiae_matsuri_radar_mark_type_none = 0 michiae_matsuri_radar_mark_type_chest = 1 michiae_matsuri_radar_mark_type_challenge = 2 class CookBonusType(Enum): cook_bonus_none = 0 cook_bonus_replace = 1 cook_bonus_proficiency = 2 class SummerTimeV2boatConditionType(Enum): time = 0 param = 1 class FallbackMarkTipsType(Enum): default = 0 teleport = 1 trace = 2 class ReferenceType(Enum): none = 0 use_entity = 1 use_target = 2 class QuestCondCompareType(Enum): equal = 0 greater_than = 1 less_than = 2 class RelationType(Enum): equal = 0 more_than = 1 less_and_equal = 2 between = 3 more_than_and_equal = 4 none_or_equal = 5 class SumoStageMonsterWaveType(Enum): sumo_monster_wave_time = 0 sumo_monster_wave_count = 1 class GadgetState(Enum): default = 0 gather_drop = 1 chest_locked = 101 chest_opened = 102 chest_trap = 103 chest_bramble = 104 chest_frozen = 105 chest_rock = 106 gear_start = 201 gear_stop = 202 gear_action1 = 203 gear_action2 = 204 crystal_resonate1 = 301 crystal_resonate2 = 302 crystal_explode = 303 crystal_drain = 304 statue_active = 401 action01 = 901 action02 = 902 action03 = 903 class ConfigSchedulerType(Enum): i_update = 0 i_late_pre_update = 1 i_late_post_update = 2 i_after_res_to_update_end = 3 i_late_post_update_to_next_before_late_update = 4 i_render_to_next_before_res = 5 i_render_to_next_before_late_update = 6 i_render_to_next_before_network = 7 i_after_network_to_render = 8 i_after_entity_to_effect_end = 9 i_after_late_update_post = 10 g_render_to_next_before_late_update = 100 class MoveType(Enum): normal_move = 0 combat_move = 1 combat_air = 2 combat_skill_air = 3 perform_move = 4 class MaterialType(Enum): material_none = 0 material_food = 1 material_quest = 2 material_exchange = 4 material_consume = 5 material_exp_fruit = 6 material_avatar = 7 material_adsorbate = 8 material_cricket = 9 material_elem_crystal = 10 material_weapon_exp_stone = 11 material_chest = 12 material_reliquary_material = 13 material_avatar_material = 14 material_notice_add_hp = 15 material_sea_lamp = 16 material_selectable_chest = 17 material_flycloak = 18 material_namecard = 19 material_talent = 20 material_widget = 21 material_chest_batch_use = 22 material_fake_absorbate = 23 material_consume_batch_use = 24 material_wood = 25 material_furniture_formula = 27 material_channeller_slab_buff = 28 material_furniture_suite_formula = 29 material_costume = 30 material_home_seed = 31 material_fish_bait = 32 material_fish_rod = 33 material_sumo_buff = 34 material_fireworks = 35 material_bgm = 36 material_spice_food = 37 material_activity_robot = 38 material_activity_gear = 39 material_activity_jigsaw = 40 class RecordActorType(Enum): entity = 0 effect = 1 class SettingEntryDisplayType(Enum): grade = 0 literally = 1 text_map = 2 class GuideWidgetSpecialType(Enum): normal = 0 slot = 1 character_avatar_btn = 2 character_func_btn = 3 character_avatar_btn_by_level = 4 button = 5 tab_item = 6 synthesis_list_item = 7 quest_select_item = 8 dyn_ui_item = 9 grid_scroller = 10 simple_list = 11 center_virtual_dial = 12 class GuideOpenStateType(Enum): open_state_none = 0 open_state_paimon = 1 open_state_paimon_navigation = 2 open_state_avatar_promote = 3 open_state_avatar_talent = 4 open_state_weapon_promote = 5 open_state_weapon_awaken = 6 open_state_quest_remind = 7 open_state_game_guide = 8 open_state_cook = 9 open_state_weapon_upgrade = 10 open_state_reliquary_upgrade = 11 open_state_reliquary_promote = 12 open_state_weapon_promote_guide = 13 open_state_weapon_change_guide = 14 open_state_player_lvup_guide = 15 open_state_freshman_guide = 16 open_state_skip_freshman_guide = 17 open_state_guide_move_camera = 18 open_state_guide_scale_camera = 19 open_state_guide_keyboard = 20 open_state_guide_move = 21 open_state_guide_jump = 22 open_state_guide_sprint = 23 open_state_guide_map = 24 open_state_guide_attack = 25 open_state_guide_fly = 26 open_state_guide_talent = 27 open_state_guide_relic = 28 open_state_guide_relic_prom = 29 open_state_combine = 30 open_state_gacha = 31 open_state_guide_gacha = 32 open_state_guide_team = 33 open_state_guide_proud = 34 open_state_guide_avatar_promote = 35 open_state_guide_adventure_card = 36 open_state_forge = 37 open_state_guide_bag = 38 open_state_guide_adventure_dailytask = 40 open_state_guide_adventure_dungeon = 41 open_state_multiplayer = 49 open_state_guide_mousepc = 50 open_state_guide_multiplayer = 51 open_state_guide_dungeonreward = 52 open_state_avatar_fashion = 54 open_state_guide_kslquest = 56 open_state_personal_line = 57 open_state_guide_personal_line = 58 open_state_guide_appearance = 59 open_state_guide_process = 60 open_state_guide_personal_line_key = 61 open_state_guide_widget = 62 open_state_guide_activity_skill_aster = 63 open_state_guide_coldclimate = 64 open_state_guide_exitmultiplayer = 66 open_state_guide_theatremachanicus_build = 67 open_state_guide_theatremachanicus_rebuild = 68 open_state_guide_theatremachanicus_card = 69 open_state_guide_theatremachanicus_monster = 70 open_state_guide_theatremachanicus_mission_check = 71 open_state_guide_theatremachanicus_build_select = 72 open_state_guide_theatremachanicus_challenge_start = 73 open_state_guide_convert = 74 open_state_guide_theatremachanicus_multiplayer = 75 open_state_guide_coop_task = 76 open_state_guide_homeworld_adeptiabode = 77 open_state_guide_homeworld_deploy = 78 open_state_guide_channellerslab_equip = 79 open_state_guide_channellerslab_mp_solution = 80 open_state_guide_channellerslab_power = 81 open_state_guide_hideandseek_skill = 82 open_state_guide_homeworld_maplist = 83 open_state_guide_relicresolve = 84 open_state_guide_gguide = 85 open_state_guide_gguide_hint = 86 open_state_guide_channellerslab_equip_v2 = 87 open_state_guide_channellerslab_mp_solution_v2 = 88 open_state_guide_channellerslab_power_v2 = 89 open_state_guide_quick_teammemberchange = 90 open_state_shop_type_paimon = 1001 open_state_shop_type_city = 1002 open_state_shop_type_blacksmith = 1003 open_state_shop_type_grocery = 1004 open_state_shop_type_food = 1005 open_state_guide_sumo_team_skill = 1411 open_state_guide_fish_recipe = 1412 open_state_guide_chess_mission_check = 2001 open_state_guide_chess_build = 2002 open_state_guide_chess_wind_tower_circle = 2003 open_state_guide_chess_card_select = 2004 open_state_paimon_lvinfo = 2100 open_state_teleport_hud = 2101 open_state_guide_map_unlock = 2102 open_state_guide_paimon_lvinfo = 2103 open_state_guide_ambortransport = 2104 open_state_guide_fly_second = 2105 open_state_guide_kaeya_clue = 2106 open_state_guide_rogue_map = 2205 open_state_guide_rogue_rune = 2206 open_state_guide_bartender_formula = 2210 open_state_guide_bartender_mix = 2211 open_state_guide_bartender_cup = 2212 open_state_guide_potion_configure = 2401 open_state_guide_lanv2_firework = 2402 open_state_guide_crystallink_buff = 2601 open_state_guide_music_game_v3_real_time_edit = 2701 open_state_guide_music_game_v3_timeline_edit = 2702 open_state_guide_music_game_v3_setting = 2703 open_state_guide_robotgacha = 2704 open_state_guide_fragile_resin = 2800 class DraftExecType(Enum): draft_exec_none = 0 draft_exec_gallery = 1 draft_exec_hide_and_seek = 2 draft_exec_autostart_gallery = 3 class ChessCardNumericalModificationType(Enum): card_numerical_default_type = 0 card_numerical_attack = 1 card_numerical_mastery = 2 card_numerical_attack_interval = 3 card_numerical_attack_range = 4 class ParticleEmitLevelType(Enum): extreme_low = 0 low = 1 middle = 2 high = 3 class FoodQualityType(Enum): food_quality_none = 0 food_quality_strange = 1 food_quality_ordinary = 2 food_quality_delicious = 3 class ActivityGachaRobot(Enum): robot_type_none = 0 robot_type_normal = 1 robot_type_hidden = 2 class GuideAvatarState(Enum): normal = 0 move = 1 can_fly = 2 fly = 3 try_to_move = 4 can_promote = 5 can_up_grade = 6 class RegionShape(Enum): region_none = 0 region_sphere = 1 region_cubic = 2 region_cylinder = 3 region_polygon = 4 class BlendMoveType(Enum): none = 0 blend_move = 1 blend_move3d = 2 class TargetType(Enum): none = 0 alliance = 1 enemy = 2 self = 3 self_camp = 4 all = 5 all_except_self = 6 class OpActivityBonusSourceType(Enum): source_type_none = 0 source_type_blossom = 1 source_type_dungeon = 2 class GroupEntityType(Enum): none = 0 monster = 1 npc = 2 gadget = 3 trigger = 4 class CameraShakeType(Enum): center = 0 custom_vector = 1 hit_vector = 2 class TurnMode(Enum): prefer_target_to_input = 0 only_input = 1 only_target = 2 prefer_target_to_camera = 3 only_camera = 4 class FishSkillType(Enum): fish_skill_none = 0 fish_skill_hp = 1 fish_skill_force = 2 fish_skill_time = 3 class WidgetCameraActionType(Enum): widget_camera_action_none = 0 widget_camera_action_notify_server = 1 class ActivityGroupLinkPlayType(Enum): default = 0 winter_camp_race = 1 winter_camp_explore = 2 winter_camp_battle = 3 lantern_rite_salvage_prevent = 4 lantern_rite_salvage_escort = 5 lantern_rite_salvage_sea = 6 lantern_rite_salvage_land = 7 lantern_rite_salvage_boss = 8 michiae_matsuri_dark_challenge = 9 summer_time_v2_boat = 10 class BartenderCupType(Enum): bartender_cup_none = 0 bartender_cup_small = 1 bartender_cup_medium = 2 bartender_cup_big = 3 class ExhibitionServerTriggerType(Enum): exhibition_server_trigger_none = 0 exhibition_server_trigger_test = 1 exhibition_server_trigger_hide_and_seek_hunter_win_last_time = 2 exhibition_server_trigger_hide_and_seek_hider_survival_time = 3 exhibition_server_trigger_hide_and_seek_win = 4 exhibition_server_trigger_damage_by_group_configid = 5 exhibition_server_trigger_damage_by_monsterid = 6 exhibition_server_trigger_chess_success = 7 exhibition_server_trigger_chess_settle_round = 8 exhibition_server_trigger_chess_escaped_monsters = 9 exhibition_server_trigger_chess_pick_curse_card_count = 10 exhibition_server_trigger_chess_pick_challenge_card_count = 11 exhibition_server_trigger_chess_obtain_building_points = 12 exhibition_server_trigger_chess_pick_ssr_card_count = 13 exhibition_server_trigger_chess_last_round_kill_stage_cost_time = 14 exhibition_server_trigger_mist_trial_shortest_success_time = 15 exhibition_server_trigger_mist_trial_strongest_blow = 16 exhibition_server_trigger_mist_trial_least_take_damage = 17 exhibition_server_trigger_mist_trial_element_reaction_count = 18 exhibition_server_trigger_mist_trial_element_burst_count = 19 exhibition_server_trigger_mist_trial_success = 20 exhibition_server_trigger_damage_percentage_on_monster_die = 21 exhibition_server_trigger_damage_by_groupid = 22 exhibition_server_trigger_monster_drawn_fall_by_time_groupid = 23 exhibition_server_trigger_summer_v2_dungeon_element_burst_count = 24 exhibition_server_trigger_gallery_succ_last_time = 25 class GatherSaveType(Enum): gather_save_type_none = 0 gather_save_type_low = 1 gather_save_type_mid = 2 gather_save_type_high = 3 gather_save_type_own = 4 class BonusActivityType(Enum): bonus_common = 0 bonus_xiangling = 1 bonus_babala = 2 class ExhibitionListDisplayType(Enum): exhibition_display_type_none = 0 exhibition_display_type_time_minsec = 1 exhibition_display_type_int = 2 class DungeonSubType(Enum): dungeon_sub_none = 0 dungeon_sub_reliquary = 1 dungeon_sub_talent = 2 dungeon_sub_weapon = 3 dungeon_sub_boss = 4 class ChallengeType(Enum): challenge_none = 0 challenge_kill_count = 1 challenge_kill_count_in_time = 2 challenge_survive = 3 challenge_time_fly = 4 challenge_kill_count_fast = 5 challenge_kill_count_frozen_less = 6 challenge_kill_monster_in_time = 7 challenge_trigger_in_time = 8 challenge_guard_hp = 9 challenge_kill_count_guard_hp = 10 challenge_trigger_in_time_fly = 11 challenge_trigger2_avoid_trigger1 = 12 challenge_father_succ_in_time = 13 challenge_monster_damage_count = 14 challenge_element_reaction_count = 15 challenge_freeze_enemy_in_time = 16 challenge_crystal_element_reaction_count = 17 challenge_sheild_absorb_damage_count = 18 challenge_element_trial = 19 challenge_swirl_element_reaction_count = 20 challenge_die_less_in_time = 21 challenge_survive_in_time = 22 challenge_trigger_count = 23 class QuestShowType(Enum): quest_show = 0 quest_hidden = 1 class CustomGadgetSlotType(Enum): customgadget_slot_type_none = 0 customgadget_slot_type_furniture = 1 class LogicOperation(Enum): and_ = 0 or_ = 1 not_ = 2 class CenterPosType(Enum): bottom_center = 0 center = 1 class GroupIoType(Enum): group_io_type_default = 0 group_io_type_flow = 1 class SelectTargetDefaultType(Enum): first = 0 loop = 1 none = 2 class SectrGameObjectPathHashHackType(Enum): none = 0 stone_tint = 1 class EnvironmentType(Enum): environment_none = 0 environment_general = 1 environment_grass = 2 environment_riverside = 3 environment_mountain = 4 environment_crab = 5 environment_butterfly = 6 environment_grassshopper = 7 environment_bush = 8 environment_firefly = 9 environment_woods = 10 environment_butterfly_inazuma_high = 11 environment_butterfly_inazuma_low = 12 environment_firefly_inazuma = 13 environment_crab_inazuma = 14 environment_lizard_inazuma = 15 class SubChallengeFadeOutType(Enum): subchallenge_fadeout_type_none = 0 subchallenge_fadeout_type_success = 1 subchallenge_fadeout_type_fail = 2 subchallenge_fadeout_type_finish = 3 class SceneMpType(Enum): scene_mp_none = 0 scene_mp_single_player_single_mode = 1 class EmoRecordTypeEnum(Enum): reset_emotion = 0 reset_phoneme = 1 set_emotion = 2 set_phoneme = 3 set_emotion_and_phoneme = 4 toggle = 5 play_sequence_sub = 6 play_sequence = 7 clear_emotion = 8 toggle_eye_ctrl = 9 clear_sequence = 10 blink = 11 class MainQuestTagType(Enum): mainquest_tag_none = 0 mainquest_tag_guide = 1 mainquest_tag_activity = 2 class ShopmallRecommendCondType(Enum): shopmall_recommend_cond_type_none = 0 shopmall_recommend_cond_player_level_ge = 1 shopmall_recommend_cond_time_begin = 2 shopmall_recommend_cond_time_end = 3 class BlackScreenType(Enum): to_keep_from_black = 0 to_black = 1 from_black = 2 blend_out = 3 keep_black = 4 class TeamResonanceCondType(Enum): team_resonance_cond_none = 0 team_resonance_cond_all_different = 1 class ConfigAiCombatRole(Enum): unclassified = 0 fighter = 1 mage = 2 sup = 3 combatrole_count = 4 class ShowType(Enum): showtype_show = 0 showtype_hide = 1 class PaimonRequestFrom(Enum): self_tick = 1 dev_ui = 2 task = 3 navigation = 4 class ConfigGraphicSettingEntrySortType(Enum): none = 0 num_ascend = 1 num_descend = 2 class PerfCostRatioGrade(Enum): min = 0 low = 1 middle = 2 high = 4 max = 10 class CustomGadgetRootType(Enum): customgadget_root_none = 0 customgadget_root_furniture = 1 customgadget_root_activity_flower = 2 customgadget_root_activity_snowman = 3 customgadget_root_activity_irodori_flower = 4 customgadget_root_acticity_island_mountain = 5 class MapTagType(Enum): big_world = 0 home_world = 1 islands = 2 abyssalisle = 3 michiae_matsuri = 4 the_chasm = 5 dream_island = 6 class TriggerType(Enum): trigger_once = 0 trigger_no_repeat = 1 trigger_always = 2 class DailyTaskFinishType(Enum): daily_finish_none = 0 daily_finish_monster_id_num = 1 daily_finish_gadget_id_num = 2 daily_finish_monster_config_num = 3 daily_finish_gadget_config_num = 4 daily_finish_monster_num = 5 daily_finish_chest_config = 6 daily_finish_gather = 7 daily_finish_challenge = 8 class BeFollowState(Enum): ing = 0 waiting = 1 trans = 2 pre_failed = 3 failed = 4 success = 5 class RemoveActorType(Enum): none = 0 remove = 1 remove_with_disappear = 2 class SystemValuerType(Enum): none = 0 element_level_co = 1 player_element_level_co = 2 player_shield_level_co = 3 player_element_level_co_with_mastery = 4 class RefreshIndexType(Enum): refreshindex_monster = 0 refreshindex_gadget = 1 class PointMapVisibility(Enum): normal = 0 on_unlocked = 1 never = 2 class GetPosType(Enum): center = 0 class QuestGuideAuto(Enum): quest_guide_auto_none = 0 quest_guide_auto_enable = 1 quest_guide_auto_disable = 2 class StateType(Enum): buff_none = 0 buff_control = 1 class EquipType(Enum): equip_none = 0 equip_bracer = 1 equip_necklace = 2 equip_shoes = 3 equip_ring = 4 equip_dress = 5 equip_weapon = 6 class BanGroupType(Enum): ban_group_invalid = 0 ban_group_common = 1 ban_group_transport_only = 2 ban_group_transport_map = 3 ban_group_transpor_goto_scene = 4 class TextParamType(Enum): text_param_none = 0 text_param_avatar_name = 1 text_param_routine_type = 2 class AttackType(Enum): none = 0 melee = 1 range = 2 default = 3 class WidgetOccupyTag(Enum): action_panel = 1 fly_attach = 2 class PhotographTaskType(Enum): photograph_task_type_normal = 0 photograph_task_type_interaction = 1 class MotionBlurQuality(Enum): low = 0 high = 1 very_high = 2 class ReunionPrivilegeType(Enum): reunion_privilege_type_none = 0 reunion_privilege_type_dungeon = 1 reunion_privilege_type_blossom = 2 class TeamType(Enum): cur_team = 0 big_team = 1 class InputActionType(Enum): internal = -1 move_horizontal = 0 move_vertical = 1 open_map = 2 open_character = 3 open_bag = 4 open_paimon = 5 toggle_quest_book = 6 to_avatar1 = 7 to_avatar2 = 8 to_avatar3 = 9 help = 10 jump_or_skill4 = 15 skill1 = 16 skill2 = 17 quest_transport = 18 right_stick_button = 19 skill5 = 20 sprint_or_skill3 = 21 talk_or_pick = 22 move_forward = 23 move_left = 24 move_right = 25 move_backward = 26 toggle_attack_mode = 27 enter_focus_mode = 28 move = 29 view_horizontal = 30 view_vertical = 31 change_view = 32 wheel_menu_trigger = 33 left_shoulder = 34 right_shoulder = 35 menu_confirm = 40 menu_left = 41 menu_back = 42 d_pad_up = 43 d_pad_right = 44 d_pad_down = 45 d_pad_left = 46 left_stick_up = 47 left_stick_right = 48 left_stick_down = 49 left_stick_left = 50 left_trigger = 51 right_trigger = 52 slip = 53 zoom_camera = 54 slow_move = 55 change_with_skill = 56 reset_camera = 57 debug_menu = 58 right_stick_up = 59 right_stick_right = 60 right_stick_down = 61 right_stick_left = 62 menu_up = 63 right_stick_vertical = 64 multiplayer = 65 to_avatar4 = 66 left_stick_button = 67 right_stick_horizontal = 68 left_stick_horizontal = 69 left_stick_vertical = 70 menu_right = 71 menu_down = 72 open_gacha = 73 open_chat = 75 open_notify = 76 open_dungeon_factor = 77 to_avatar5 = 78 open_handbook = 79 track_quest = 80 open_push_tips = 81 open_activity_normal = 82 open_battle_pass = 83 challenge_interrupt = 84 challenge_interrupt_joystick = 85 hide = 86 quick_use = 87 activity_skill = 88 extera_select_up = 89 extera_select_down = 90 extera_select_left = 91 extera_select_right = 92 music_game_left_up = 94 music_game_left_right = 95 music_game_left_down = 96 music_game_left_left = 97 music_game_right_up = 98 music_game_right_right = 99 music_game_right_down = 100 music_game_right_left = 101 music_game_free1 = 102 music_game_free2 = 103 music_game_free3 = 104 music_game_free4 = 105 music_game_free5 = 106 music_game_free6 = 107 music_game_free7 = 108 music_game_free8 = 109 music_game_free9 = 110 music_game_free10 = 111 music_game_free11 = 112 music_game_free12 = 113 music_game_free13 = 114 music_game_free14 = 115 music_game_free15 = 116 music_game_free16 = 117 music_game_free17 = 118 music_game_free18 = 119 music_game_free19 = 120 music_game_free20 = 121 music_game_free21 = 122 menu_next = 123 f1 = 124 f2 = 125 f3 = 126 return_ = 127 left_stick_move = 128 open_homeworld_handbook = 129 open_homeworld_editor = 130 open_team_page = 131 open_friend_page = 132 object_turn_up = 133 object_turn_down = 134 object_turn_left = 135 object_turn_right = 136 right_stick_move = 137 mouse_left_button = 138 mouse_right_button = 139 homeworld_create_custom_suite_joystick = 141 camera_move_up = 142 camera_move_down = 143 custom_level_switch_float_mode = 144 custom_level_deploy_confirm = 145 arrow_up = 146 arrow_down = 147 arrow_right = 148 arrow_left = 149 space = 150 left_control = 151 undo = 152 save = 153 object_turn_clockwise = 154 object_turn_anti_clockwise = 155 to_avatar1trigger_skill = 1000 to_avatar2trigger_skill = 1001 to_avatar3trigger_skill = 1002 to_avatar4trigger_skill = 1003 to_avatar5trigger_skill = 1004 class QuestCondType(Enum): quest_cond_none = 0 quest_cond_state_equal = 1 quest_cond_state_not_equal = 2 quest_cond_pack_have_item = 3 quest_cond_avatar_element_equal = 4 quest_cond_avatar_element_not_equal = 5 quest_cond_avatar_can_change_element = 6 quest_cond_city_level_equal_greater = 7 quest_cond_item_num_less_than = 8 quest_cond_daily_task_start = 9 quest_cond_open_state_equal = 10 quest_cond_daily_task_open = 11 quest_cond_daily_task_reward_can_get = 12 quest_cond_daily_task_reward_received = 13 quest_cond_player_level_reward_can_get = 14 quest_cond_exploration_reward_can_get = 15 quest_cond_is_world_owner = 16 quest_cond_player_level_equal_greater = 17 quest_cond_scene_area_unlocked = 18 quest_cond_item_giving_actived = 19 quest_cond_item_giving_finished = 20 quest_cond_is_daytime = 21 quest_cond_current_avatar = 22 quest_cond_current_area = 23 quest_cond_quest_var_equal = 24 quest_cond_quest_var_greater = 25 quest_cond_quest_var_less = 26 quest_cond_forge_have_finish = 27 quest_cond_daily_task_in_progress = 28 quest_cond_daily_task_finished = 29 quest_cond_activity_cond = 30 quest_cond_activity_open = 31 quest_cond_daily_task_var_gt = 32 quest_cond_daily_task_var_eq = 33 quest_cond_daily_task_var_lt = 34 quest_cond_bargain_item_gt = 35 quest_cond_bargain_item_eq = 36 quest_cond_bargain_item_lt = 37 quest_cond_complete_talk = 38 quest_cond_not_have_blossom_talk = 39 quest_cond_is_cur_blossom_talk = 40 quest_cond_quest_not_receive = 41 quest_cond_quest_server_cond_valid = 42 quest_cond_activity_client_cond = 43 quest_cond_quest_global_var_equal = 44 quest_cond_quest_global_var_greater = 45 quest_cond_quest_global_var_less = 46 quest_cond_personal_line_unlock = 47 quest_cond_city_reputation_request = 48 quest_cond_main_coop_start = 49 quest_cond_main_coop_enter_save_point = 50 quest_cond_city_reputation_level = 51 quest_cond_city_reputation_unlock = 52 quest_cond_lua_notify = 53 quest_cond_cur_climate = 54 quest_cond_activity_end = 55 quest_cond_coop_point_running = 56 quest_cond_gadget_talk_state_equal = 57 quest_cond_avatar_fetter_gt = 58 quest_cond_avatar_fetter_eq = 59 quest_cond_avatar_fetter_lt = 60 quest_cond_new_homeworld_moudle_unlock = 61 quest_cond_new_homeworld_level_reward = 62 quest_cond_new_homeworld_make_finish = 63 quest_cond_homeworld_npc_event = 64 quest_cond_time_var_gt_eq = 65 quest_cond_time_var_pass_day = 66 quest_cond_homeworld_npc_new_talk = 67 quest_cond_player_choose_male = 68 quest_cond_history_got_any_item = 69 quest_cond_learned_recipe = 70 quest_cond_lunarite_region_unlocked = 71 quest_cond_lunarite_has_region_hint_count = 72 quest_cond_lunarite_collect_finish = 73 quest_cond_lunarite_mark_all_finish = 74 quest_cond_new_homeworld_shop_item = 75 quest_cond_scene_point_unlock = 76 quest_cond_scene_level_tag_eq = 77 quest_cond_player_enter_region = 78 quest_cond_activity_schedule_open_and_cond = 79 class RewardSourceSystemType(Enum): none = 0 mp_play = 1 class BlossomChestShowType(Enum): blossom_chest_showtype_blossom = 0 blossom_chest_showtype_no_resin = 1 class PlaceNameConditionType(Enum): default = 0 quest = 1 map_area = 2 erosion_area = 3 class UgcFormulaType(Enum): linear = 0 axial = 1 class LunaRiteRegionType(Enum): luna_rite_region_type_invalid = 0 luna_rite_region_type_liyue = 1 luna_rite_region_type_mengde = 2 luna_rite_region_type_dragonspine = 3 class FishingEvent(Enum): none = 0 qte_start = 1 qte_trigger = 2 request_quit = 3 cast_anchor_point = 4 select_bait = 5 pull = 6 notify_bait = 7 class ProudLifeEffectType(Enum): proud_effect_none = 0 proud_effect_combine_return_material = 1 proud_effect_combine_multiply_output = 2 proud_effect_combine_extra_output = 3 proud_effect_combine_add_extra_prob = 4 proud_effect_combine_return_special_material = 5 proud_effect_cook_extra_proficiency = 101 proud_effect_cook_widen_judge_area = 102 proud_effect_cook_add_bonus_prob = 103 proud_effect_cook_perfect_multi_output = 104 proud_effect_cook_prob_multi_output = 105 proud_effect_cook_can_not_cook = 106 proud_effect_forge_reduce_time = 203 proud_effect_forge_add_extra_prob = 204 proud_effect_forge_return_material = 205 proud_effect_expedition_shorten_time = 301 proud_effect_expedition_extra_output = 302 proud_effect_furniture_make_return_material = 401 proud_effect_weapon_promote_reduce_scoin = 501 proud_effect_fishing_extra_output = 601 proud_effect_hit_tree_extra_output = 701 class LifeState(Enum): life_none = 0 life_alive = 1 life_dead = 2 life_revive = 3 class CutsceneInitPosType(Enum): free = 0 relative_to_local_avatar = 1 relative_to_intee = 2 other = 3 relative_to_local_avatar_with_rotation = 4 relative_to_entity_with_rotation = 5 class ChestShowCutsceneType(Enum): none = 0 camera_look = 1 cutscene = 2 class AbilityState(Enum): none = 0 invincible = 1 deny_lock_on = 2 is_ghost_to_allied = 4 is_ghost_to_enemy = 8 element_burning = 16 element_wet = 32 element_frozen = 128 lock_hp = 512 ignore_trigger_bullet = 1024 element_shock = 2048 struggle = 4096 element_rock = 8192 element_ice = 32768 element_freeze = 65536 attack_up = 131072 defense_up = 262144 speed_up = 524288 defense_down = 1048576 speed_down = 2097152 element_wind = 4194304 element_electric = 8388608 element_fire = 16777216 no_heal = 33554432 limbo = 67108864 mute_taunt = 134217728 element_petrifaction = 268435456 ignore_add_energy = 1073741824 element_grass = 2147483648 element_overdose = 4294967296 corruption = 8589934592 unlock_frequency_limit = 17179869184 element_dead_time = 34359738368 class ElementType(Enum): none = 0 fire = 1 water = 2 grass = 3 electric = 4 ice = 5 frozen = 6 wind = 7 rock = 8 anti_fire = 9 vehicle_mute_ice = 10 count = 11 class HeightPosType(Enum): bottom = 0 center = 1 class LogicType(Enum): logic_none = 0 logic_and = 1 logic_or = 2 logic_not = 3 logic_a_and_etcor = 4 logic_a_and_b_and_etcor = 5 logic_a_or_etcand = 6 logic_a_or_b_or_etcand = 7 logic_a_and_b_or_etcand = 8 class OfferingMaxLevelLimitType(Enum): offering_max_level_limit_none = 0 offering_max_level_limit_normal = 1 offering_max_level_limit_michiae = 2 class InterActionTargetType(Enum): none = 0 vehicle_skiff = 1 class SourceJumpType(Enum): jump_none = 0 jump_investigation = 1 jump_mall = 2 class FleurFairDungeonStatType(Enum): fleur_fair_dungeon_stat_none = 0 fleur_fair_dungeon_stat_group_variable = 1 fleur_fair_dungeon_stat_monster_hurt = 2 class DropRandomType(Enum): drop_random_by_weight = 0 drop_random_independent = 1 class ItemLimitConstValueType(Enum): limit_const_value_day_bonus_count = 1 limit_const_value_bonus_output_switch_one = 2 limit_const_value_bonus_output_switch_two = 3 class TaskId(Enum): move_task_id = 0 narrator_task_id = 1 lock_task_id = 2 thread_task_id = 3 transmit_btn_id = 4 force_walk_id = 5 steer_to_autonomy_id = 6 home_task_id = 7 safe_circle = 8 npc_follow_player_id = 9 warning_task_id = 10 class SceneBuildingType(Enum): none = 0 church = 1 knights = 2 pub = 3 souvenir = 4 restaurant = 5 general_cargo = 6 blacksmith = 7 team_arranger = 8 adventurers = 9 alchemy = 10 sea_lamp_giving = 11 blacksmith_liyue = 12 souvenir_liyue = 13 restaurant_liyue = 14 reputation = 15 reputation_liyue = 16 aster_middle_npc = 17 elder_tree = 18 miscs_marvs = 19 treasure_map_npc = 20 drake_primo_rock_npc = 21 activity_blessing_npc = 22 mechanicus_npc = 23 activity_arena_challenge = 24 fleur_fair_npc = 25 hide_and_seek_npc = 26 channeller_slab_npc = 27 bounce_conjuring_npc = 28 reputation_inazuma = 29 perpetual_npc = 30 oraionokami_tree = 31 restaurant_inazuma = 32 blacksmith_inazuma = 33 souvenir_inazuma = 34 bugyowu = 35 chashitsu = 36 luna_rite_npc = 37 fish = 38 fish_liyue = 39 fish_inazuma = 40 music_game_npc = 41 grow_flowers_npc = 42 animal_capture_shop_npc = 43 alcor_transmit = 44 ashanpo_npc = 45 projection_game_entry = 46 michiae_offering = 47 bartender_npc = 48 luminance_stone_npc = 2601 irodori_flower_npc = 2610 irodori_photo_npc = 2611 irodori_master_npc = 2612 irodori_chess_npc = 2613 music_game_v3npc = 2701 activity_gacha_npc = 2702 cocoon_space = 2703 gear_game_entry = 2801 island_party_npc = 2802 class AvatarUseType(Enum): avatar_test = 0 avatar_sync_test = 1 avatar_formal = 2 avatar_abandon = 3 class MpPlayerSettleType(Enum): mp_play_settle_type_none = 0 mp_play_settle_type_watcher_finish = 1 mp_play_settle_type_watcher_progress = 2 mp_play_settle_type_monster_take_demage = 3 mp_play_settle_type_monster_kill_num = 4 mp_play_settle_type_monster_killer = 5 class ReputationEntranceType(Enum): reputation_entrance_none = 0 reputation_entrance_quest = 1 reputation_entrance_request = 2 reputation_entrance_explore = 3 reputation_entrance_hunter = 4 class VoicePersonality(Enum): first = 0 third = 1 npc = 2 class RealScenePointType(Enum): other = 0 trans_point_normal = 1 trans_point_statue = 2 trans_point_portal = 3 dungeon_entry = 4 dungeon_exit = 5 dungeon_way_point = 6 dungeon_quit_point = 7 dungeon_reward_point = 8 personal_scene_jump_point = 9 scene_building_point = 10 dungeon_slip_revive_point = 11 vehicle_summon_point = 12 class InputValueType(Enum): button_input = 0 one_axis_input = 1 two_axis_input = 2 class TalkHeroType(Enum): talk_hero_local = 0 talk_hero_main = 1 class PinType(Enum): none = 0 reference_counting = 1 fully_pin = 2 class BagTab(Enum): tab_none = 0 tab_weapon = 1 tab_equip = 2 tab_avatar = 3 tab_food = 4 tab_material = 5 tab_quest = 6 tab_consume = 7 tab_widget = 8 tab_homeworld = 9 class EquipEntityType(Enum): none = 0 sword_one_hand = 1 cross_bow = 2 small_shield = 3 spear = 4 catalyst = 5 bow = 6 claymore = 7 pole = 8 class FleurFairMiniGameType(Enum): fleur_fair_mini_game_none = 0 fleur_fair_mini_game_balloon = 1 fleur_fair_mini_game_fall = 2 fleur_fair_mini_game_music = 3 class SalvagePlayType(Enum): salvage_play_type_none = 0 salvage_play_type_land = 1 salvage_play_type_sea = 2 salvage_play_type_carriage = 3 salvage_play_type_escort = 4 salvage_play_type_boss = 5 class GalleryType(Enum): gallery_type_none = 0 gallery_type_balloon = 1 gallery_type_fall = 2 gallery_type_arena_challenge = 3 gallery_type_catch_flower = 4 gallery_type_fadeout_floor = 5 gallery_type_avoid_rays = 6 gallery_type_broken_floor = 7 gallery_type_bullet_game = 8 gallery_type_avoid_bubbles = 9 gallery_type_remember_road = 10 gallery_type_mist_trial = 11 gallery_type_hide_and_seek = 12 gallery_type_buoyant_combat = 13 gallery_type_bounce_conjuring = 14 gallery_type_handball = 15 gallery_type_sumo_combat = 16 gallery_type_fish = 17 gallery_type_dig_combat = 18 gallery_type_triathlon = 19 gallery_type_home_racing = 20 gallery_type_salvage_prevent = 21 gallery_type_salvage_escort = 22 gallery_type_home_balloon = 23 gallery_type_crystal_link = 24 gallery_type_photo = 25 gallery_type_sword_way = 26 gallery_type_luminance_stone_challenge = 27 gallery_type_home_seek_furniture = 28 gallery_type_island_party_raft = 30 gallery_type_island_party_sail = 31 gallery_type_island_party_down_hill = 32 gallery_type_summer_time_v2_boat_race = 33 class BlinkHitSceneTestType(Enum): blink_hit_scene_test_by_straight_line = 0 blink_hit_scene_test_by_three_segments = 1 class AttackCostType(Enum): max = 0 min = 1 sum = 2 class MatchLimitType(Enum): match_limit_type_none = 0 match_limit_type_map_unlock = 1 match_limit_type_quest_finish = 2 class TimerLimitType(Enum): finite = 0 infinite = 1 class EffigyDifficulty(Enum): effigy_difficulty_none = 0 effigy_difficulty_primer = 1 effigy_difficulty_normal = 2 effigy_difficulty_hard = 3 effigy_difficulty_expert = 4 class TdPlayTowerType(Enum): default = 0 fire = 1 water = 2 ice = 3 wind = 4 electric = 5 simple = 6 supporter = 7 builder = 8 mine = 9 gate = 10 class IrodoriChessCardNumericalModificationType(Enum): irodori_card_numerical_default_type = 0 irodori_card_numerical_attack = 1 irodori_card_numerical_mastery = 2 irodori_card_numerical_attack_interval = 3 irodori_card_numerical_attack_range = 4 class TargetPositionAreaLevel(Enum): city = 0 first_area = 1 second_area = 2 class MoveToType(Enum): none = 0 walk = 1 run = 2 noneaccurate = 3 direct = 4 class IrodoriMasterMedalType(Enum): irodori_master_medal_none = 0 irodori_master_medal_gold = 1 irodori_master_medal_silver = 2 class MarkCustomType(Enum): red_circle = 0 blue_circle = 1 other = 2 class MonsterRarityType(Enum): monster_rarity_none = 0 monster_rarity_small_monster = 1 monster_rarity_elite_monster = 2 monster_rarity_boss_monster = 3 monster_rarity_big_boss_monster = 4 monster_rarity_small_env_animal = 5 class AnimalCodexCountType(Enum): codex_count_type_none = 0 codex_count_type_kill = 1 codex_count_type_fish = 2 codex_count_type_capture = 3 class HomeWorldFieldType(Enum): home_field_none = 0 home_field_dry = 1 home_field_flower = 2 home_field_water = 3 class WatcherPredicateType(Enum): predicate_none = 0 predicate_quest_finish = 1 predicate_current_avatar = 2 class RogueDiaryTiredType(Enum): rogue_diary_tired_none = 0 rogue_diary_tired_select = 1 rogue_diary_tired_random = 2 rogue_diary_tired_all = 3 class AudioEmitterMultiPositionType(Enum): multi_sources = 0 multi_directions = 1 class BillboardType(Enum): none = 0 sneak = 1 icon = 2 class ExhibitionCardOrderType(Enum): exhibition_card_order_none = 0 exhibition_card_order_less_better = 1 exhibition_card_order_greater_better = 2 class CombatBillboardSize(Enum): normal = 0 big = 1 grand = 2 small = 3 class ChessCardNumericalModificationMode(Enum): card_numerical_default_mode = 0 card_numerical_base = 1 card_numerical_percentage = 2 class CoopActionType(Enum): coop_action_none = 0 coop_action_temperament_add = 1 coop_action_temperament_minus = 2 coop_action_confidence_add = 3 coop_action_confidence_minus = 4 coop_action_temp_value_set = 5 coop_action_select_temperament_set = 6 coop_action_temp_value_add = 7 coop_action_temp_value_minus = 8 class EntityAttackFilter(Enum): all_entities = 0 only_water = 1 only_grass = 2 only_grass_and_water = 3 ignore_scene_prop = 4 class UgcMoveType(Enum): loop = 0 reciprocate = 1 once = 2 class ActivityIslandPartyStageType(Enum): stage_type_none = 0 stage_type_raft = 1 stage_type_sail = 2 stage_type_down_hill = 3 class SphereDetectDirection(Enum): none = 0 center_to_side = 1 class SkillDrag(Enum): drag_none = 0 drag_rotate_camera = 1 drag_rotate_character = 2 class CombatPropertyIndex(Enum): hp = 0 attack = 1 defense = 2 weight = 3 endure = 4 level = 5 elementaddhurt = 6 defenseignore = 7 class ProgressBillboardType(Enum): general = 0 miracle = 1 cook = 2 class ShaderUseType(Enum): none = 0 character = 1 gadget = 2 class GuidePageType(Enum): normal = 0 equip_promote = 1 relic_promote = 2 talent_info = 3 relic_info = 4 weapon_info = 5 skill_info = 6 weapon_select = 7 relic_select = 8 theatre_mechanicus_building = 9 theatre_mechanicus_rebuilding = 10 class ItemType(Enum): item_none = 0 item_virtual = 1 item_material = 2 item_reliquary = 3 item_weapon = 4 item_display = 5 item_furniture = 6 class ItemLimitType(Enum): item_limit_none = 0 item_limit_unlimited = 1 item_limit_gm = 2 item_limit_quest = 3 item_limit_city_upgrade = 4 item_limit_unlock_trans_point = 5 item_limit_unlock_dungeon = 6 item_limit_investigation = 7 item_limit_player_level_upgrade = 8 item_limit_push_tips_reward = 9 item_limit_avatar_fetter_reward = 10 item_limit_world_area_explore_event_reward = 11 item_limit_activity_sea_lamp = 12 item_limit_battle_pass_paid_reward = 13 item_limit_oneoff_big_world_drop = 14 item_limit_gameplay_niche = 15 item_limit_oneoff_dungeon_drop = 16 item_limit_oneoff_plunder_drop = 17 item_limit_oneoff_subfield_drop = 18 item_limit_big_world_chest = 19 item_limit_gacha_token_drop = 20 item_limit_daily_big_world_drop = 22 item_limit_daily_dungeon_drop = 23 item_limit_daily_plunder_drop = 24 item_limit_daily_subfield_drop = 25 item_limit_daily_sea_lamp_drop = 26 item_limit_normal_dungeon = 27 item_limit_daily_task = 28 item_limit_daily_task_score = 29 item_limit_rand_task_drop = 30 item_limit_expedition = 31 item_limit_small_monster_die = 32 item_limit_elite_monster_die = 33 item_limit_boss_monster_die = 34 item_limit_big_boss_monster_die = 35 item_limit_small_env_animal_die = 36 item_limit_monster_excel_drop = 37 item_limit_repeatable_quest_reward = 38 item_limit_env_animal = 39 item_limit_gather = 40 item_limit_operation_daily_activity = 41 item_limit_quest_add_item = 42 item_limit_bonus_activity = 43 item_limit_tower_monthly = 44 item_limit_battle_pass_level_reward = 45 item_limit_sign_in = 46 item_limit_gacha = 47 item_limit_shop = 48 item_limit_cook = 49 item_limit_compound = 50 item_limit_combine = 51 item_limit_forge = 52 item_limit_random_chest = 53 item_limit_use_item = 54 item_limit_use_item_reward = 55 item_limit_blossom_chest_drop = 56 item_limit_mp_play_drop = 57 item_limit_forge_drop = 58 item_limit_mp_play_crucible_drop = 59 item_limit_activity_crucible_reward = 60 item_limit_activity_reward = 61 item_limit_activity_trial_avatar = 62 item_limit_activity_salesman = 63 item_limit_rebate = 64 item_limit_month_card = 65 item_limit_birthday_benefit = 67 item_limit_achievement_reward = 68 item_limit_achievement_goal_reward = 69 item_limit_destroy_return_material = 70 item_limit_tower_reward = 71 item_limit_share_reward = 72 item_limit_fetter_level_reward = 73 item_limit_dungeon_first_pass_reward = 74 item_limit_codex_levelup_reward = 75 item_limit_activity_delivery = 76 item_limit_city_reputation_level = 77 item_limit_city_reputation_quest = 78 item_limit_upgrade_weapon_return_material = 79 item_limit_city_reputation_request = 80 item_limit_hunting_reward = 81 item_limit_city_reputation_explore = 82 item_limit_activity_flight_reward = 83 item_limit_activity_aster_reward = 84 item_limit_activity_aster_drop = 85 item_limit_activity_drgaon_spine_reward = 86 item_limit_activity_dragon_spine_drop = 87 item_limit_snow_mountain_tree_task = 88 item_limit_snow_mountain_tree_level = 89 item_limit_activity_salesman_chest_drop = 90 item_limit_activity_effigy_reward = 91 item_limit_reunion_reward = 92 item_limit_avatar_promote_reward = 93 item_limit_activity_salesman_mp = 94 item_limit_activity_treasure_map_reward = 95 item_limit_resin_card = 96 item_limit_activity_blessing = 97 item_limit_miracle_ring_reward = 98 item_limit_activity_expedition_reward = 99 item_limit_mechanicus_battle_settle_reward = 100 item_limit_sea_lamp_activity_avatar_reward = 101 item_limit_player_exp_overflow_transform = 1401 item_limit_activity_arena_challenge_reward = 1402 item_limit_coop_task_reward = 1403 item_limit_water_spirit_reward = 1404 item_limit_region_search_reward = 1405 item_limit_water_spirit_drop = 1406 item_limtt_activity_fleur_fair_reward = 1407 item_limit_hit_tree_drop = 1501 item_limit_activity_mist_trial = 1502 item_limit_activity_channeller_slab = 1503 item_limit_activity_hide_and_seek = 1504 item_limit_activity_find_hilichurl = 1505 item_limit_furniture_make_cancel = 1506 item_limit_home_levelup_reward = 1507 item_limit_furniture_make = 1508 item_limit_activity_condition_mail_reward = 1509 item_limit_battle_pass_notify_mail_reward = 1510 item_limit_activity_channeller_slab_avatar_reward = 1511 item_limit_home_resource = 1512 item_limit_operation_welfare = 1513 item_limit_activity_summer_time_reward = 1601 item_limit_activity_echo_shell = 1602 item_limit_reliquary_decompose = 1603 item_limit_home_fetter = 1604 item_limit_home_event_reward = 1605 item_limit_activity_buoyant_combat_reward = 1606 item_limit_activity_bounce_conjuring_reward = 1607 item_limit_oraionokami_reward = 2000 item_limit_book_leaf_drop = 2001 item_limit_exploration_line_level_reward = 2002 item_limit_activity_blitz_rush_reward = 2003 item_limit_activity_blitz_rush_avatar_reward = 2004 item_limit_activity_chess_reward = 2005 item_limit_home_plant_box_seed_drop = 2006 item_limit_home_plant_gather_drop = 2007 item_limit_home_furniture_make_return = 2008 item_limit_activity_sumo = 2100 item_limit_activity_luna_rite = 2101 item_limit_fish_reward = 2102 item_limit_activity_moonfin_trial = 2103 item_limit_activity_luna_rite_drop = 2104 item_limit_activity_roguelike_dungeon = 2200 item_limit_activity_roguelike_dungeon_avatar_reward = 2201 item_limit_activity_plant_flower = 2202 item_limit_activity_dig_reward = 2203 item_limit_activity_dig_drop = 2204 item_limit_activity_music_game_reward = 2205 item_limit_capture_reward = 2300 item_limit_winter_camp_reward = 2301 item_limit_winter_camp_drop = 2302 item_limit_capture_none_drop = 2303 item_limit_activity_hachi_reward = 2304 item_limit_activity_potion = 2400 item_limit_activity_tanuki_travel = 2401 item_limit_activity_lantern_rite = 2402 item_limit_activity_lantern_rite_avatar_reward = 2403 item_limit_activity_lantern_rite_drop = 2404 item_limit_activity_michiae_matsuri = 2500 item_limit_activity_michiae_matsuri_drop = 2501 item_limit_activity_bartender = 2502 item_limit_ugc_reward = 2503 item_limit_lumen_stone_level = 2600 item_limit_activity_crystal_link = 2601 item_limit_activity_spice = 2602 item_limit_activity_irodori = 2603 item_limit_activity_irodori_avatar_reward = 2604 item_limit_activity_photo = 2605 item_limit_activity_gacha = 2700 item_limit_activity_rogue_diary = 2701 item_limit_comeback_questionnaire = 2702 item_limit_luminance_stone_challenge = 2703 item_limit_giving_take_back = 2800 item_limit_activity_summer_time_v2 = 2801 item_limit_activity_summer_time_v2_avatar_reward = 2802 item_limit_activity_island_party = 2803 item_limit_activity_gear = 2804 class DungunEntryType(Enum): dungen_entry_type_none = 0 dungen_entry_type_avatar_exp = 1 dungen_entry_type_weapon_promote = 2 dungen_entry_type_avatar_talent = 3 dungen_entry_type_reliquary = 4 dungen_entry_type_scoin = 5 dungeon_entry_type_obscurae = 6 dungeon_entry_type_normal = 7 dungeon_entry_type_trial = 8 dungeon_entry_type_effigy = 9 dungeon_entry_type_fleur_fair = 10 dungeon_entry_type_channeller_slab_loop = 11 dungeon_entry_type_channeller_slab_one_off = 12 dungeon_entry_type_blitz_rush = 13 dungeon_entry_type_sumo = 14 dungeon_entry_type_activity = 15 dungeon_entry_type_hachi = 16 class InterTimingType(Enum): enter = 0 btn = 1 exit = 2 class TypeCount(Enum): reliquary_type_count = 5 class NavType(Enum): none = 0 obstacle = 1 class CollectorType(Enum): wind_seed = 1 class ReactionTriggerType(Enum): avatar = 0 other = 1 class MapAreaState(Enum): mist_close = 0 mist_open = 1 class SceneTagCondType(Enum): scene_tag_cond_type_none = 0 scene_tag_cond_type_specific_activity_open = 1 scene_tag_cond_type_quest_global_var_equal = 2 scene_tag_cond_type_activity_content_open = 4 scene_tag_cond_type_quest_finish = 5 class ActionCompoundType(Enum): two_axis = 0 all_press = 1 class RandTaskContentType(Enum): rand_task_content_none = 0 rand_task_content_cleanup = 1 rand_task_content_rescue = 2 rand_task_content_guard = 3 rand_task_content_attack = 4 rand_task_content_investigate = 5 rand_task_content_pay = 6 rand_task_content_dungeon = 7 rand_task_content_tall = 8 class GroupRecordType(Enum): group_record_type_none = 0 group_record_type_racing = 1 group_record_type_balloon = 2 group_record_type_stake = 3 group_record_type_seek = 4 class RoundType(Enum): round_type_floor = 0 round_type_round = 1 round_type_ceil = 2 class ChessCardTargetType(Enum): chess_card_target_default = 0 chess_card_target_all = 1 chess_card_target_gadgets = 2 class QteActionType(Enum): qte_action_none = 0 qte_action_finish_quest = 1 qte_action_fail_quest = 2 class ConfigKeyCode(Enum): none = 0 backspace = 8 tab = 9 clear = 12 return_ = 13 pause = 19 escape = 27 space = 32 exclaim = 33 double_quote = 34 hash = 35 dollar = 36 ampersand = 38 quote = 39 left_paren = 40 right_paren = 41 asterisk = 42 plus = 43 comma = 44 minus = 45 period = 46 slash = 47 alpha0 = 48 alpha1 = 49 alpha2 = 50 alpha3 = 51 alpha4 = 52 alpha5 = 53 alpha6 = 54 alpha7 = 55 alpha8 = 56 alpha9 = 57 colon = 58 semicolon = 59 less = 60 equals = 61 greater = 62 question = 63 at = 64 left_bracket = 91 backslash = 92 right_bracket = 93 caret = 94 underscore = 95 back_quote = 96 a = 97 b = 98 c = 99 d = 100 e = 101 f = 102 g = 103 h = 104 i = 105 j = 106 k = 107 l = 108 m = 109 n = 110 o = 111 p = 112 q = 113 r = 114 s = 115 t = 116 u = 117 v = 118 w = 119 x = 120 y = 121 z = 122 delete = 127 keypad0 = 256 keypad1 = 257 keypad2 = 258 keypad3 = 259 keypad4 = 260 keypad5 = 261 keypad6 = 262 keypad7 = 263 keypad8 = 264 keypad9 = 265 keypad_period = 266 keypad_divide = 267 keypad_multiply = 268 keypad_minus = 269 keypad_plus = 270 keypad_enter = 271 keypad_equals = 272 up_arrow = 273 down_arrow = 274 right_arrow = 275 left_arrow = 276 insert = 277 home = 278 end = 279 page_up = 280 page_down = 281 f1 = 282 f2 = 283 f3 = 284 f4 = 285 f5 = 286 f6 = 287 f7 = 288 f8 = 289 f9 = 290 f10 = 291 f11 = 292 f12 = 293 f13 = 294 f14 = 295 f15 = 296 numlock = 300 caps_lock = 301 scroll_lock = 302 right_shift = 303 left_shift = 304 right_control = 305 left_control = 306 right_alt = 307 left_alt = 308 right_command = 309 left_command = 310 left_windows = 311 right_windows = 312 alt_gr = 313 help = 315 print = 316 sys_req = 317 break_ = 318 menu = 319 mouse0 = 323 mouse1 = 324 mouse2 = 325 mouse3 = 326 mouse4 = 327 mouse5 = 328 mouse6 = 329 joystick_button0 = 330 joystick_button1 = 331 joystick_button2 = 332 joystick_button3 = 333 joystick_button4 = 334 joystick_button5 = 335 joystick_button6 = 336 joystick_button7 = 337 joystick_button8 = 338 joystick_button9 = 339 joystick_button10 = 340 joystick_button11 = 341 joystick_button12 = 342 joystick_button13 = 343 joystick_button14 = 344 joystick_button15 = 345 joystick_button16 = 346 joystick_button17 = 347 joystick_button18 = 348 joystick_button19 = 349 joystick1button0 = 350 joystick1button1 = 351 joystick1button2 = 352 joystick1button3 = 353 joystick1button4 = 354 joystick1button5 = 355 joystick1button6 = 356 joystick1button7 = 357 joystick1button8 = 358 joystick1button9 = 359 joystick1button10 = 360 joystick1button11 = 361 joystick1button12 = 362 joystick1button13 = 363 joystick1button14 = 364 joystick1button15 = 365 joystick1button16 = 366 joystick1button17 = 367 joystick1button18 = 368 joystick1button19 = 369 joystick2button0 = 370 joystick2button1 = 371 joystick2button2 = 372 joystick2button3 = 373 joystick2button4 = 374 joystick2button5 = 375 joystick2button6 = 376 joystick2button7 = 377 joystick2button8 = 378 joystick2button9 = 379 joystick2button10 = 380 joystick2button11 = 381 joystick2button12 = 382 joystick2button13 = 383 joystick2button14 = 384 joystick2button15 = 385 joystick2button16 = 386 joystick2button17 = 387 joystick2button18 = 388 joystick2button19 = 389 joystick3button0 = 390 joystick3button1 = 391 joystick3button2 = 392 joystick3button3 = 393 joystick3button4 = 394 joystick3button5 = 395 joystick3button6 = 396 joystick3button7 = 397 joystick3button8 = 398 joystick3button9 = 399 joystick3button10 = 400 joystick3button11 = 401 joystick3button12 = 402 joystick3button13 = 403 joystick3button14 = 404 joystick3button15 = 405 joystick3button16 = 406 joystick3button17 = 407 joystick3button18 = 408 joystick3button19 = 409 joystick4button0 = 410 joystick4button1 = 411 joystick4button2 = 412 joystick4button3 = 413 joystick4button4 = 414 joystick4button5 = 415 joystick4button6 = 416 joystick4button7 = 417 joystick4button8 = 418 joystick4button9 = 419 joystick4button10 = 420 joystick4button11 = 421 joystick4button12 = 422 joystick4button13 = 423 joystick4button14 = 424 joystick4button15 = 425 joystick4button16 = 426 joystick4button17 = 427 joystick4button18 = 428 joystick4button19 = 429 joystick5button0 = 430 joystick5button1 = 431 joystick5button2 = 432 joystick5button3 = 433 joystick5button4 = 434 joystick5button5 = 435 joystick5button6 = 436 joystick5button7 = 437 joystick5button8 = 438 joystick5button9 = 439 joystick5button10 = 440 joystick5button11 = 441 joystick5button12 = 442 joystick5button13 = 443 joystick5button14 = 444 joystick5button15 = 445 joystick5button16 = 446 joystick5button17 = 447 joystick5button18 = 448 joystick5button19 = 449 joystick6button0 = 450 joystick6button1 = 451 joystick6button2 = 452 joystick6button3 = 453 joystick6button4 = 454 joystick6button5 = 455 joystick6button6 = 456 joystick6button7 = 457 joystick6button8 = 458 joystick6button9 = 459 joystick6button10 = 460 joystick6button11 = 461 joystick6button12 = 462 joystick6button13 = 463 joystick6button14 = 464 joystick6button15 = 465 joystick6button16 = 466 joystick6button17 = 467 joystick6button18 = 468 joystick6button19 = 469 joystick7button0 = 470 joystick7button1 = 471 joystick7button2 = 472 joystick7button3 = 473 joystick7button4 = 474 joystick7button5 = 475 joystick7button6 = 476 joystick7button7 = 477 joystick7button8 = 478 joystick7button9 = 479 joystick7button10 = 480 joystick7button11 = 481 joystick7button12 = 482 joystick7button13 = 483 joystick7button14 = 484 joystick7button15 = 485 joystick7button16 = 486 joystick7button17 = 487 joystick7button18 = 488 joystick7button19 = 489 joystick8button0 = 490 joystick8button1 = 491 joystick8button2 = 492 joystick8button3 = 493 joystick8button4 = 494 joystick8button5 = 495 joystick8button6 = 496 joystick8button7 = 497 joystick8button8 = 498 joystick8button9 = 499 joystick8button10 = 500 joystick8button11 = 501 joystick8button12 = 502 joystick8button13 = 503 joystick8button14 = 504 joystick8button15 = 505 joystick8button16 = 506 joystick8button17 = 507 joystick8button18 = 508 joystick8button19 = 509 class CompoundType(Enum): compound_none = 0 compound_cook = 1 compound_placeholder_2 = 2 class ActivityGroupLinkType(Enum): discrete = 0 circle = 1 class MechanicusCardEffectType(Enum): mechanicus_card_effect_none = 0 mechanicus_card_effect_set_sgv = 1 mechanicus_card_effect_mod_cost = 2 mechanicus_card_effect_mod_refund = 3 mechanicus_card_effect_set_home_hp = 4 mechanicus_card_effect_add_home_hp = 5 mechanicus_card_effect_add_kill_points = 6 mechanicus_card_effect_mod_kill_points = 7 mechanicus_card_effect_add_gear_num = 8 mechanicus_card_effect_kill_gears = 9 mechanicus_card_effect_grant_points = 10 mechanicus_card_notify_lua = 11 mechanicus_passive_aura_bonus_points = 12 mechanicus_passive_aura_sgv = 13 class NpcBodyType(Enum): none = 0 avatar_male = 1 avatar_lady = 2 avatar_boy = 3 avatar_girl = 4 avatar_loli = 5 avatar_paimon = 6 npc_male = 7 npc_female = 8 npc_muscleman = 9 npc_elder = 10 npc_child = 11 barbara = 12 bennett = 13 chongyun = 14 noel = 15 diona = 16 sayu = 17 tohma = 18 beidou = 19 gorou = 20 ningguang = 21 class CutsceneIndexType(Enum): cutscene = 0 video = 1 other = 2 class FadeTintQualityLevel(Enum): very_low = 1 low = 2 middle = 3 high = 4 very_high = 5 num = 6 class RoguelikeEffectType(Enum): roguelike_effect_none = 0 roguelike_effect_static_combat = 1 roguelike_effect_dynamic_combat = 2 roguelike_effect_disable_spring_cell = 3 roguelike_effect_add_talent = 4 roguelike_effect_add_level_trap = 5 roguelike_effect_clear_level_trap = 6 roguelike_effect_random_clear_a_curse = 7 roguelike_effect_clear_all_curse = 8 roguelike_effect_add_rune_max_count = 9 roguelike_effect_add_rune_use_count = 10 roguelike_effect_fill_rune_use_count = 11 roguelike_effect_use_rune_prob_not_sub = 12 roguelike_effect_clear_mist = 13 roguelike_effect_add_resource = 14 roguelike_effect_random_avatar_noheal = 15 roguelike_effect_add_card_type_weight = 16 roguelike_effect_sub_refresh_card_cost = 17 roguelike_effect_change_gadget_num = 18 roguelike_effect_sub_curse_prob = 19 roguelike_effect_prob_free_refresh_card = 20 roguelike_effect_add_card_type_weight_room_first = 21 roguelike_effect_at_most_trap_count = 22 roguelike_effect_spring_and_boss = 23 roguelike_effect_at_least_store_count = 24 roguelike_effect_ban_guard = 25 class GalleryProgressScoreType(Enum): gallery_progress_score_none = 0 gallery_progress_score_no_degrade = 1 class MistTrialClientSyncType(Enum): mist_trial_sync_none = 0 mist_trial_sync_progress = 1 mist_trial_sync_stat_value = 2 mist_trial_sync_challenge_left_time = 3 class RoutineFinishType(Enum): routine_finish_none = 0 routine_finish_kill_monster = 1 routine_finish_gather = 2 routine_challenge_finish = 3 class MarkViewType(Enum): none = 0 map_mark_normal = 1 map_mark_local_avatar = 2 map_mark_local_sight = 3 map_mark_south = 4 map_mark_mini_other = 5 map_mark_custom = 6 other = 7 class ExtraAbilityState(Enum): start = 0 success = 1 interrupt = 2 class FetterCondType(Enum): fetter_cond_none = 0 fetter_cond_fetter_level = 1 fetter_cond_avatar_level = 2 fetter_cond_finish_dungeon = 3 fetter_cond_unlock_trans_point = 4 fetter_cond_unlock_area = 5 fetter_cond_finish_quest = 6 fetter_cond_avatar_promote_level = 7 fetter_cond_player_birthday = 8 fetter_cond_avatar_birthday = 9 fetter_cond_not_open = 10 fetter_cond_finish_parent_quest = 11 fetter_cond_unlock_arena_by_city_id = 12 class HitLevel(Enum): mute = 0 shake = 1 light = 2 heavy = 3 air = 4 class BonusSourceType(Enum): bonus_source_none = 0 bonus_source_reunion = 1 bonus_source_op_activity = 2 class DungeonCondType(Enum): dungeon_cond_none = 0 dungeon_cond_kill_monster = 3 dungeon_cond_kill_group_monster = 5 dungeon_cond_kill_type_monster = 7 dungeon_cond_finish_quest = 9 dungeon_cond_kill_monster_count = 11 dungeon_cond_in_time = 13 dungeon_cond_finish_challenge = 14 dungeon_cond_end_multistage_play = 15 class MonsterSecurityLevel(Enum): normal = 0 elite = 1 boss = 2 class FatherChallengeProperty(Enum): duration = 0 cur_succ = 1 cur_fail = 2 sum_succ = 3 sum_fail = 4 class FrameFaceAnimationPlayType(Enum): loop = 0 normal = 1 clamp = 2 class ExcelMailType(Enum): excel_mail_none = 0 excel_mail_tower_daily = 1 excel_mail_tower_monthly = 2 excel_mail_tower_overflow_first_pass = 3 class VoiceLanguageType(Enum): chinese = 0 english = 1 japanese = 2 korean = 3 class SectrLayerType(Enum): persistence = 0 terrain = 1 static_model = 2 stone_model = 3 dynamic_model = 4 navmesh = 5 collider = 6 very_high_model = 7 terrain_grass = 8 tree_model = 9 water_tile = 10 fog_texture = 11 small_light = 12 far_light = 13 dynamic_small_light = 14 dynamic_far_light = 15 reflection_prob = 16 volume = 17 height_terrain_grass = 18 class RaycastType(Enum): down_to_ground_only_in_air = 0 down_to_ground_and_water_only_in_air = 1 down_to_ground_only_in_water = 2 class MaskGuideType(Enum): normal = 0 black = 1 transparent = 2 class MusicKeyType(Enum): left_up = 0 left_right = 1 left_down = 2 left_left = 3 right_up = 4 right_right = 5 right_down = 6 right_left = 7 class DungeonEntryType(Enum): normal = 0 weekly = 1 daily = 2 tower = 3 effigy = 4 fleur_fair = 5 arena = 6 channeller_slab_loop = 7 channeller_slab_one_off = 8 blitz_rush = 9 sumo = 10 roguelike = 11 activity_hachi = 12 activity_potion = 13 activity_mini_eldritch = 14 custom_level = 15 crystal_link = 16 rogue_diary = 17 activity_summer_time_v2story = 18 activity_summer_time_v2battle = 19 class GatherAreaType(Enum): ability_radar_collectables_mengde = 1 ability_radar_collectables_liyue = 2 ability_radar_collectables_daoqi = 3 ability_radar_collectables_michiae_matsuri = 101 ability_radar_ore = 998 collect_general = 999 class DialogSteerType(Enum): free = 0 absolute = 1 to_local_avatar = 2 return_ = 3 to_local_avatar_advanced = 4 look_at_only = 5 to_target = 6 to_target_advanced = 7 follow_camera = 8 other = 9 class ChargeFillEffect(Enum): charing_fill_positive = 0 charing_fill_negative = 1 charing_fill_none = 2 class VehicleType(Enum): none = 0 ship = 1 skiff = 2 class MainPageUiDisableType(Enum): none = 0 easy_touch = 1 action_panel = 2 team_btn = 3 message_tips = 4 intee_panel = 5 aim_container = 6 self_rtt = 7 top_btns = 8 map_info = 9 chat_info = 10 move = 11 game_info = 12 dialog = 13 main_btn = 14 class MarkPluginIconType(Enum): none = 0 boss = 1 character = 2 paimon = 3 class DropElemBallType(Enum): level_control = 0 big_world_only = 1 force_drop = 2 class UnstickAction(Enum): stay = 0 keep = 1 destroy = 2 stay_and_return = 3 class MusicBehaviourIgnorance(Enum): beat = 1 bar = 2 grid = 4 cue = 8 exit = 16 time = 32 stimulus = 64 class DocumentType(Enum): book = 0 video = 1 class SalesmanSpecialRewardObtainMethod(Enum): method_day_probability = 0 method_day_accumulation = 1 class ActivitySkillTarget(Enum): ast_avatar = 0 ast_team = 1 ast_play = 2 class NeuronName(Enum): hit = 0 fear = 1 hit_buddy = 2 asleep = 3 awake = 4 weather_bad = 5 weather_clearsky = 6 weather_cloudy = 7 weather_foggy = 8 weather_rain = 9 weather_snow = 10 weather_storm = 11 surround = 12 hungry = 13 block_avatar_landing = 14 preach = 15 supervise = 16 train = 17 dance = 18 make = 19 build = 20 search = 21 sit = 22 threat = 23 invalid = 24 class StateAudioEventUsage(Enum): any = 0 in_set = 1 except_ = 2 class OpActivityBonusType(Enum): type_none = 0 type_daily = 1 type_sum = 2 class ExploreEventType(Enum): explore_event_none = 0 explore_event_unlock_point = 1 explore_event_open_chest = 2 explore_event_clear_group_monster = 3 explore_event_item_add = 4 explore_event_enter_force = 5 explore_event_open_chest_by_gadget = 6 explore_event_gather = 7 class RefreshType(Enum): refresh_none = 0 refresh_interval = 1 refresh_daily = 2 refresh_wee_kl_y = 3 refresh_daybegin_interval = 4 class TalkShowType(Enum): talk_show_default = 0 talk_show_force_select = 1 class JobType(Enum): job_none = 0 job_swordman = 1 job_archer = 2 class SpeicalFurnitureType(Enum): normal_furnitrue = 0 block_dependent = 1 farm_field = 2 teleport_point = 3 fishpond = 4 npc = 5 apartment = 6 furniture_suite = 7 paimon = 8 fish = 9 custom_base_furnitrue = 10 custom_node_furnitrue = 11 virtual_furnitrue = 12 group_furnitrue = 13 coop_picture_frame = 14 change_bgm_furniture = 15 server_gadget = 16 class RogueCellType(Enum): rogue_cell_type_none = 0 rogue_cell_type_init = 1 rogue_cell_type_store = 2 rogue_cell_type_elite = 3 rogue_cell_type_normal = 4 rogue_cell_type_spring = 5 rogue_cell_type_boss = 6 rogue_cell_type_chest = 7 class MarkLayerType(Enum): normal = 0 first = 1 last = 2 class AbilityGroupTargetType(Enum): ability_group_target_none = 0 ability_group_target_avatar = 1 ability_group_target_team = 2 class GuideCmdType(Enum): bag_page_scroll_tab = 0 class TouchInteractType(Enum): default = 0 normal_chest = 1 flora_chest = 2 multiple_reward = 3 single_reward = 4 owner_only_reward = 5 gadget_chain = 6 widget_mp_support = 7 post_ui_interact_gadget_action = 8 general_ui_interact = 9 class OfferingActionType(Enum): offering_action_none = 0 offering_action_open_routine = 1 offering_action_close_routine = 2 offering_action_notify_group = 3 offering_action_set_gadget_chain_level = 4 offering_action_set_lumen_stone_level = 5 class AddActionType(Enum): idle = 0 reset_global_value = 1 class CircleDetectDirection(Enum): center_to_side = 0 clockwise = 1 counterclockwise = 2 class FacingMoveType(Enum): forward_only = 0 forward_backward = 1 four_direction = 2 left_right = 3 air_blend = 4 air_blend3d = 5 class IndicatorDistanceInfoType(Enum): none = 0 to_avatar = 1 remaining_distance = 2 class CreaterBornTag(Enum): vertical_coordinate = 0 vertical_surface = 1 class AntialiasingMethod(Enum): none = 0 smaa = 3 taa = 4 class PaimonSkill(Enum): show = 1 anger = 2 domangic = 3 guide = 4 hope = 5 wave = 6 show_move = 7 blow_normal = 8 blow_continuous = 9 class BlossomRewardType(Enum): blossom_reward_type_default = 0 blossom_reward_type_to_bag = 1 class MpPlaySettleType(Enum): mp_play_settle_none = 0 mp_play_settle_old = 1 mp_play_settle_card = 2 class CombineUnlockMethod(Enum): combine_unlock_none = 0 combine_unlock_quest = 1 combine_unlock_formula = 2 combine_unlock_sea_lamp_quest = 3 combine_unlock_activity_cond_meet = 4 class DungeonEntrySatisfiedConditionType(Enum): dungeon_entry_condition_none = 0 dungeon_entry_condition_level = 1 dungeon_entry_condition_quest = 2 class FleurFairDungeonStatMethod(Enum): fleur_fair_dungeon_stat_method_none = 0 fleur_fair_dungeon_stat_method_maximum = 1 fleur_fair_dungeon_stat_method_minimum = 2 class PerfItemValueType(Enum): int_perf_num = 0 string_key_perf_item = 2 grade_perf_item = 3 bool_perf_item = 4 combine_perf_item = 5 class ClimateTrendType(Enum): none = 0 rise = 1 fade = 2 all = 3 class HomeWorldAreaType(Enum): interior_area = 0 exterior_area = 1 class WorldAreaType(Enum): level_none = 0 level_1 = 1 level_2 = 2 level_3 = 3 level_play = 10 class ProductPlayType(Enum): product_play_type_none = 0 product_play_type_battle_pass_normal = 1 product_play_type_battle_pass_extra = 2 product_play_type_battle_pass_upgrade = 3 class GuidePlatform(Enum): none = 0 i_os = 1 standalone = 2 android = 3 ps4 = 4 switch = 5 class SubChallengeBannerType(Enum): subchallenge_banner_type_none = 0 subchallenge_banner_type_success = 1 subchallenge_banner_type_fail = 2 subchallenge_banner_type_show_final = 3 subchallenge_banner_type_hide_final = 4 class ConfigAiSkillType(Enum): free = 0 combat = 1 on_aware = 2 on_alert = 3 on_nerve = 4 action_point = 5 combat_buddy = 6 class GachaItemParentType(Enum): gacha_item_parent_invalid = 0 gacha_item_parent_s5 = 1 gacha_item_parent_s4 = 2 gacha_item_parent_s3 = 3 class QualityType(Enum): quality_none = 0 quality_white = 1 quality_green = 2 quality_blue = 3 quality_purple = 4 quality_orange = 5 quality_orange_sp = 105 class VoicePositioning(Enum): two_dimensional = 0 three_dimensional = 1 tutorial_special = 2 three_dimensional_passby = 3 inner_monologue = 4 class TileSpecialType(Enum): none = 0 world_type_begin = 1 world_grass = 2 world_water = 3 world_electric_water = 4 world_type_end = 5 count = 6 class ConditionType(Enum): condition_none = 0 condition_quest = 1 condition_player_level = 2 condition_var_eq = 3 condition_var_ne = 4 condition_var_gt = 5 condition_var_lt = 6 condition_unlock_point = 7 condition_player_level_gt_eq = 8 condition_player_level_lt = 9 condition_specific_activity_open = 10 condition_activity_type_open = 11 condition_quest_global_var_equal = 12 condition_quest_global_var_greater = 13 condition_quest_global_var_less = 14 condition_finish_achievement = 15 class ActivityGachaRobotType(Enum): robot_type_none = 0 robot_type_shape = 1 robot_type_color = 2 robot_type_action = 3 robot_type_num = 4 class NewActivityType(Enum): new_activity_general = 0 new_activity_sea_lamp = 1 new_activity_crucible = 2 new_activity_salesman = 3 new_activity_trial_avatar = 4 new_activity_signin = 5 new_activity_bonus = 6 new_activity_newbeebonus = 7 new_activity_personal_liine = 8 new_activity_delivery = 9 new_activity_flight = 10 new_activity_temp = 99 new_activity_aster = 1100 new_activity_dragonspine = 1200 new_activity_reunion = 1201 new_activity_effigy = 1202 new_activity_tower_reset = 1203 new_activity_treasure_map = 1204 new_activity_salesman_mp = 1205 new_activity_blessing = 1300 new_activity_expedition = 1301 new_activity_sea_lamp_new = 1302 new_activity_fleur_fair = 1400 new_activity_operations_bonus = 1401 new_activity_arena_challenge = 1402 new_activity_water_spirit_challenge = 1403 new_activity_signin_companion = 1404 new_activity_coop = 1405 new_activity_monster_banner_drake_primo_rock = 1501 new_activity_channeler_slab = 1502 new_activity_misttrial = 1503 new_activity_hideandseek = 1504 new_activity_find_hilichurl = 1505 new_activity_monster_banner_effigy_ice = 1506 new_activity_homeworld = 1507 new_activity_h5 = 1508 new_activity_summer_time = 1600 new_activity_buoyant_combat = 1601 new_activity_echo_shell = 1602 new_activity_bounce_conjuring = 1603 new_activity_daoqi_advertisement = 1604 new_activity_blitz_rush = 2001 new_activity_chess = 2002 new_activity_monster_banner_effigy_fire = 2003 new_activity_monster_banner_perpetual = 2004 new_activity_personal_liine_2 = 2005 new_activity_general_banner = 2100 new_activity_luna_rite = 2101 new_activity_sumo = 2102 new_activity_moonfin_trial = 2103 new_activity_monster_banner_effigy_water = 2104 new_activity_monster_banner_raijin = 2105 new_activity_plant_flower = 2200 new_activity_roguelike_dungeon = 2201 new_activity_music_game = 2202 new_activity_dig = 2203 new_activity_moonfin_banner = 2204 new_activity_winter_camp = 2301 new_activity_hachi = 2302 new_activity_potion = 2400 new_activity_tanuki_travel = 2401 new_activity_sea_lamp_2_4 = 2402 new_activity_michiae_matsuri = 2501 new_activity_bartender = 2502 new_activity_ugc = 2503 new_activity_irodori = 2600 new_activity_crystal_link = 2601 new_activity_spice = 2602 new_activity_photo = 2603 new_activity_luminance_stone_challenge = 2702 new_activity_gacha = 2703 new_activity_rogue_diary = 2704 new_activity_summer_time_2_8 = 2801 new_activity_gear = 2802 new_activity_island_party = 2803 class EchoShellType(Enum): echo_shell_type_normal_echo = 0 echo_shell_type_special_echo = 1 echo_shell_type_normal_image = 2 echo_shell_type_special_image = 3 echo_shell_type_normal_interact = 4 class RouteRecordMode(Enum): none = 0 prereach = 1 reach = 2 class FollowTarget(Enum): local_avatar = 0 local_avatar_synced_location = 1 local_avatar_authority = 2 target_entity = 3 group_gadget_entity = 4 group_monster_entity = 5 npc_entity = 6 class ActionPanelState(Enum): normal = 0 jump = 1 climb = 2 fly = 3 aim = 4 fast_aim = 5 swim = 6 ladder = 7 squat = 8 combat_air = 9 perform = 10 close_all = 11 class BonusActivityState(Enum): bonus_activity_state_none = 0 bonus_activity_state_unstarted = 1 bonus_activity_state_unfinished = 2 bonus_activity_state_unrewarded = 3 bonus_activity_state_rewarded = 4 class DontDestroyOnLoadType(Enum): false = 0 once = 1 always = 2 class TalentPointType(Enum): talent_point_none = 0 talent_point_small = 1 talent_point_big = 2 class DiePatternSwitchMixinPriority(Enum): entity = 0 level_play = 1 num = 2 class HuntingMonsterGroupType(Enum): hunting_group_type_none = 0 hunting_group_type_clue = 1 hunting_group_type_associated = 2 def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfConfigGadgetUiItemGroupShowCondLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfConfigGadgetUiItemGroupShowCondLengthU(self._io, self, self._root)) class ConfigGuideAddCmd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cmd_type: self.cmd_type = Output.EnumGuideCmdType(self._io, self, self._root) if self.has_field_para_value: self.para_value = self._io.read_f4le() @property def has_field_cmd_type(self): if hasattr(self, '_m_has_field_cmd_type'): return self._m_has_field_cmd_type self._m_has_field_cmd_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cmd_type', None) @property def has_field_para_value(self): if hasattr(self, '_m_has_field_para_value'): return self._m_has_field_para_value self._m_has_field_para_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_para_value', None) class ArrayOfEnumTalentFilterCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumTalentFilterCond(self._io, self, self._root)) class ConfigAiBirdCirclingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius', None) class DispConfigMoveCorrection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigMoveCorrection(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigParabolaBulletMoveCorrection(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class WeaponCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class Int64NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ArrayOfIdCountConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IdCountConfig(self._io, self, self._root)) class ActivityGearLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_provided_gears: self.provided_gears = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_day_index: self.open_day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_redpoint_id_sub_page: self.redpoint_id_sub_page = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_redpoint_id_level_select: self.redpoint_id_level_select = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_provided_gears(self): if hasattr(self, '_m_has_field_provided_gears'): return self._m_has_field_provided_gears self._m_has_field_provided_gears = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_provided_gears', None) @property def has_field_open_day_index(self): if hasattr(self, '_m_has_field_open_day_index'): return self._m_has_field_open_day_index self._m_has_field_open_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day_index', None) @property def has_field_redpoint_id_sub_page(self): if hasattr(self, '_m_has_field_redpoint_id_sub_page'): return self._m_has_field_redpoint_id_sub_page self._m_has_field_redpoint_id_sub_page = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_redpoint_id_sub_page', None) @property def has_field_redpoint_id_level_select(self): if hasattr(self, '_m_has_field_redpoint_id_level_select'): return self._m_has_field_redpoint_id_level_select self._m_has_field_redpoint_id_level_select = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_redpoint_id_level_select', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ModifyAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param_special: self.param_special = AuxTypes.String(self._io, self, self._root) if self.has_field_param_delta: self.param_delta = AuxTypes.DynamicArgument(self._io, self, self._root) if self.has_field_param_ratio: self.param_ratio = AuxTypes.DynamicArgument(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_param_special(self): if hasattr(self, '_m_has_field_param_special'): return self._m_has_field_param_special self._m_has_field_param_special = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param_special', None) @property def has_field_param_delta(self): if hasattr(self, '_m_has_field_param_delta'): return self._m_has_field_param_delta self._m_has_field_param_delta = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param_delta', None) @property def has_field_param_ratio(self): if hasattr(self, '_m_has_field_param_ratio'): return self._m_has_field_param_ratio self._m_has_field_param_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_param_ratio', None) class ConfigElementShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_damage_ratio: self.damage_ratio = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_restraint: self.restraint = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_damage_ratio(self): if hasattr(self, '_m_has_field_damage_ratio'): return self._m_has_field_damage_ratio self._m_has_field_damage_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_damage_ratio', None) @property def has_field_restraint(self): if hasattr(self, '_m_has_field_restraint'): return self._m_has_field_restraint self._m_has_field_restraint = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_restraint', None) class FishRodExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_base_attack: self.base_attack = self._io.read_f4le() if self.has_field_attack_acc: self.attack_acc = self._io.read_f4le() if self.has_field_max_attack: self.max_attack = self._io.read_f4le() if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attack_mag: self.attack_mag = self._io.read_f4le() @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_base_attack(self): if hasattr(self, '_m_has_field_base_attack'): return self._m_has_field_base_attack self._m_has_field_base_attack = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_base_attack', None) @property def has_field_attack_mag(self): if hasattr(self, '_m_has_field_attack_mag'): return self._m_has_field_attack_mag self._m_has_field_attack_mag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_attack_mag', None) @property def has_field_max_attack(self): if hasattr(self, '_m_has_field_max_attack'): return self._m_has_field_max_attack self._m_has_field_max_attack = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_attack', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_attack_acc(self): if hasattr(self, '_m_has_field_attack_acc'): return self._m_has_field_attack_acc self._m_has_field_attack_acc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_attack_acc', None) class ActivityHachiStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SignInCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfItemOptionArrayInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_requirement_array: self.requirement_array = Output.ArrayOfConfigGraphicsRequirementLengthU(self._io, self, self._root) @property def has_field_requirement_array(self): if hasattr(self, '_m_has_field_requirement_array'): return self._m_has_field_requirement_array self._m_has_field_requirement_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_requirement_array', None) class ChestLevelSetConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetSkillAnchor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class InterPriorityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReputationQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_parent_quest_id: self.parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_parent_quest_id(self): if hasattr(self, '_m_has_field_parent_quest_id'): return self._m_has_field_parent_quest_id self._m_has_field_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_parent_quest_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_order', None) class BartenderFormulaTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) class ConfigMusicStringMultiValueStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicMultiValueParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_string_params: self.string_params = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_string_params(self): if hasattr(self, '_m_has_field_string_params'): return self._m_has_field_string_params self._m_has_field_string_params = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_string_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class QuestShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExistFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerSetVisible(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_visible: self.visible = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_visible(self): if hasattr(self, '_m_has_field_visible'): return self._m_has_field_visible self._m_has_field_visible = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_visible', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumChangeFieldType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChangeFieldType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigAbilityTaskLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigAbilityTask(self._io, self, self._root)) class ConfigLocalTriggerMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_vector_param: self.vector_param = Output.Vector(self._io, self, self._root) if self.has_field_float_param: self.float_param = self._io.read_f4le() if self.has_field_string_param: self.string_param = AuxTypes.String(self._io, self, self._root) @property def has_field_vector_param(self): if hasattr(self, '_m_has_field_vector_param'): return self._m_has_field_vector_param self._m_has_field_vector_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_vector_param', None) @property def has_field_float_param(self): if hasattr(self, '_m_has_field_float_param'): return self._m_has_field_float_param self._m_has_field_float_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_float_param', None) @property def has_field_string_param(self): if hasattr(self, '_m_has_field_string_param'): return self._m_has_field_string_param self._m_has_field_string_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_string_param', None) class EntityMultiPlayerExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prop_per_vec: self.prop_per_vec = Output.ArrayOfEntityPropPerMpConfigLengthS(self._io, self, self._root) if self.has_field_endure_num_vec: self.endure_num_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_element_shield_per_vec: self.element_shield_per_vec = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_prop_per_vec(self): if hasattr(self, '_m_has_field_prop_per_vec'): return self._m_has_field_prop_per_vec self._m_has_field_prop_per_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prop_per_vec', None) @property def has_field_endure_num_vec(self): if hasattr(self, '_m_has_field_endure_num_vec'): return self._m_has_field_endure_num_vec self._m_has_field_endure_num_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_endure_num_vec', None) @property def has_field_element_shield_per_vec(self): if hasattr(self, '_m_has_field_element_shield_per_vec'): return self._m_has_field_element_shield_per_vec self._m_has_field_element_shield_per_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_element_shield_per_vec', None) class AbilityPropExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prop_name: self.prop_name = AuxTypes.String(self._io, self, self._root) if self.has_field_overall_min: self.overall_min = self._io.read_f4le() if self.has_field_overall_max: self.overall_max = self._io.read_f4le() if self.has_field_limit_tag_min: self.limit_tag_min = self._io.read_f4le() if self.has_field_limit_tag_max: self.limit_tag_max = self._io.read_f4le() if self.has_field_succeed_owner: self.succeed_owner = self._io.read_u1() @property def has_field_limit_tag_min(self): if hasattr(self, '_m_has_field_limit_tag_min'): return self._m_has_field_limit_tag_min self._m_has_field_limit_tag_min = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_limit_tag_min', None) @property def has_field_limit_tag_max(self): if hasattr(self, '_m_has_field_limit_tag_max'): return self._m_has_field_limit_tag_max self._m_has_field_limit_tag_max = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_limit_tag_max', None) @property def has_field_succeed_owner(self): if hasattr(self, '_m_has_field_succeed_owner'): return self._m_has_field_succeed_owner self._m_has_field_succeed_owner = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_succeed_owner', None) @property def has_field_prop_name(self): if hasattr(self, '_m_has_field_prop_name'): return self._m_has_field_prop_name self._m_has_field_prop_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prop_name', None) @property def has_field_overall_min(self): if hasattr(self, '_m_has_field_overall_min'): return self._m_has_field_overall_min self._m_has_field_overall_min = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_overall_min', None) @property def has_field_overall_max(self): if hasattr(self, '_m_has_field_overall_max'): return self._m_has_field_overall_max self._m_has_field_overall_max = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_overall_max', None) class EnumBillboardOffsetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BillboardOffsetType, self.data.value) return getattr(self, '_m_value', None) class TalkSelectTimeOutExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdGroupInfos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_crowd_group_infos: self.crowd_group_infos = Output.ArrayOfConfigCrowdGroupInfoLengthU(self._io, self, self._root) @property def has_field_crowd_group_infos(self): if hasattr(self, '_m_has_field_crowd_group_infos'): return self._m_has_field_crowd_group_infos self._m_has_field_crowd_group_infos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_crowd_group_infos', None) class EnumUgcMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UgcMoveType, self.data.value) return getattr(self, '_m_value', None) class ConfigQteStepCondGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cond_comb_type: self.cond_comb_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_step_cond_list: self.step_cond_list = Output.ArrayOfDispConfigQteStepBaseCondLengthU(self._io, self, self._root) @property def has_field_cond_comb_type(self): if hasattr(self, '_m_has_field_cond_comb_type'): return self._m_has_field_cond_comb_type self._m_has_field_cond_comb_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cond_comb_type', None) @property def has_field_step_cond_list(self): if hasattr(self, '_m_has_field_step_cond_list'): return self._m_has_field_step_cond_list self._m_has_field_step_cond_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_step_cond_list', None) class IrodoriFlowerGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) class GetFightProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_fight_prop_source_target: self.fight_prop_source_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_fight_prop: self.fight_prop = AuxTypes.String(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_fight_prop_source_target(self): if hasattr(self, '_m_has_field_fight_prop_source_target'): return self._m_has_field_fight_prop_source_target self._m_has_field_fight_prop_source_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_fight_prop_source_target', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_fight_prop(self): if hasattr(self, '_m_has_field_fight_prop'): return self._m_has_field_fight_prop self._m_has_field_fight_prop = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fight_prop', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ActivityIslandPartyOverallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringAuxTypesDynamicArgument(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = AuxTypes.DynamicArgument(self._io, self, self._root) class IrodoriPoetryEntityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SumoStageMonsterWaveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRoundType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoundType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigPerfStringKeyItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfStringKeyItemOptionArrayInfo(self._io, self, self._root) class BodyMaterialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRoguelikeShikigamiUnlockType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoguelikeShikigamiUnlockType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfSourceJumpConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SourceJumpConfig(self._io, self, self._root)) class AsterMidGroupsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumVoicePositioning(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VoicePositioning, self.data.value) return getattr(self, '_m_value', None) class ActivitySumoSwitchSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicSingleNoLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ActivityTanukiTravelDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_open_list: self.activity_open_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_inazuma_quest_id: self.inazuma_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sakura_quest_id: self.sakura_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_order_quest_id_list: self.pre_order_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_pre_order_quest_id_list(self): if hasattr(self, '_m_has_field_pre_order_quest_id_list'): return self._m_has_field_pre_order_quest_id_list self._m_has_field_pre_order_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pre_order_quest_id_list', None) @property def has_field_activity_open_list(self): if hasattr(self, '_m_has_field_activity_open_list'): return self._m_has_field_activity_open_list self._m_has_field_activity_open_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_activity_open_list', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_sakura_quest_id(self): if hasattr(self, '_m_has_field_sakura_quest_id'): return self._m_has_field_sakura_quest_id self._m_has_field_sakura_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_sakura_quest_id', None) @property def has_field_inazuma_quest_id(self): if hasattr(self, '_m_has_field_inazuma_quest_id'): return self._m_has_field_inazuma_quest_id self._m_has_field_inazuma_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_inazuma_quest_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class CoopTemperament(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ratio: self.ratio = self._io.read_f4le() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ratio', None) class TalkMarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OpActivityBonusTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityTanukiTravelRouteDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_index: self.open_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day_index: self.open_day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hidden_sub_quest_id: self.hidden_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_needed_home_quest_id: self.needed_home_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_needed_fish_quest_id: self.needed_fish_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_route_last_quest_id: self.route_last_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_review: self.review = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region: self.region = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_route_last_quest_id(self): if hasattr(self, '_m_has_field_route_last_quest_id'): return self._m_has_field_route_last_quest_id self._m_has_field_route_last_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_route_last_quest_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_review(self): if hasattr(self, '_m_has_field_review'): return self._m_has_field_review self._m_has_field_review = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_review', None) @property def has_field_needed_home_quest_id(self): if hasattr(self, '_m_has_field_needed_home_quest_id'): return self._m_has_field_needed_home_quest_id self._m_has_field_needed_home_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_needed_home_quest_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_open_day_index(self): if hasattr(self, '_m_has_field_open_day_index'): return self._m_has_field_open_day_index self._m_has_field_open_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day_index', None) @property def has_field_hidden_sub_quest_id(self): if hasattr(self, '_m_has_field_hidden_sub_quest_id'): return self._m_has_field_hidden_sub_quest_id self._m_has_field_hidden_sub_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_hidden_sub_quest_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_region(self): if hasattr(self, '_m_has_field_region'): return self._m_has_field_region self._m_has_field_region = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_region', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_needed_fish_quest_id(self): if hasattr(self, '_m_has_field_needed_fish_quest_id'): return self._m_has_field_needed_fish_quest_id self._m_has_field_needed_fish_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_needed_fish_quest_id', None) @property def has_field_open_index(self): if hasattr(self, '_m_has_field_open_index'): return self._m_has_field_open_index self._m_has_field_open_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_index', None) class BlossomRefreshCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRecordRendererParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_global_parameter: self.global_parameter = Output.RecordRendererGlobalParameters(self._io, self, self._root) if self.has_field_textures: self.textures = Output.ArrayOfRecordOverrideTextureLengthU(self._io, self, self._root) @property def has_field_global_parameter(self): if hasattr(self, '_m_has_field_global_parameter'): return self._m_has_field_global_parameter self._m_has_field_global_parameter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_parameter', None) @property def has_field_textures(self): if hasattr(self, '_m_has_field_textures'): return self._m_has_field_textures self._m_has_field_textures = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_textures', None) class AiBasicMoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessMapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDraftExecSubType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DraftExecSubType, self.data.value) return getattr(self, '_m_value', None) class ByNot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DictOfAuxTypesVlqBase128LeSConfigActionTokenChannel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigActionTokenChannel(self._io, self, self._root)) class NewActivityCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideGeneralConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalToken(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_action_token_group: self.action_token_group = AuxTypes.String(self._io, self, self._root) @property def has_field_action_token_group(self): if hasattr(self, '_m_has_field_action_token_group'): return self._m_has_field_action_token_group self._m_has_field_action_token_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_token_group', None) class ArrayOfWeaponAwayFromHandStateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.WeaponAwayFromHandState(self._io, self, self._root)) class BlessingScanTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiCombatPhaseComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMiracleTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MiracleTag, self.data.value) return getattr(self, '_m_value', None) class ConfigMusicIntStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_int_param: self.int_param = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_int_param(self): if hasattr(self, '_m_has_field_int_param'): return self._m_has_field_int_param self._m_has_field_int_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_param', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class CookBonusTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BillboardOffsetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigOverrideGroupConverter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPlantFlowerDailyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigSoundBankUnloadPolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigSoundBankUnloadPolicy(self._io, self, self._root) class ActivitySummerTimeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id: self.unlock_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_duration: self.content_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_player_level: self.unlock_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_personal_pre_quest: self.personal_pre_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_of_pre_quest: self.pre_quest_of_pre_quest = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id_list: self.quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_pre_quest_of_pre_quest(self): if hasattr(self, '_m_has_field_pre_quest_of_pre_quest'): return self._m_has_field_pre_quest_of_pre_quest self._m_has_field_pre_quest_of_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest_of_pre_quest', None) @property def has_field_unlock_quest_id(self): if hasattr(self, '_m_has_field_unlock_quest_id'): return self._m_has_field_unlock_quest_id self._m_has_field_unlock_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_quest_id', None) @property def has_field_personal_pre_quest(self): if hasattr(self, '_m_has_field_personal_pre_quest'): return self._m_has_field_personal_pre_quest self._m_has_field_personal_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_personal_pre_quest', None) @property def has_field_unlock_player_level(self): if hasattr(self, '_m_has_field_unlock_player_level'): return self._m_has_field_unlock_player_level self._m_has_field_unlock_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_player_level', None) @property def has_field_content_duration(self): if hasattr(self, '_m_has_field_content_duration'): return self._m_has_field_content_duration self._m_has_field_content_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content_duration', None) @property def has_field_quest_id_list(self): if hasattr(self, '_m_has_field_quest_id_list'): return self._m_has_field_quest_id_list self._m_has_field_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_quest_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class SceneSubTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ComparePropertyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigGadgetStateActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigGadgetStateAction(self._io, self, self._root)) class ConfigShadowQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shadow_distance: self.shadow_distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shadow_resolution: self.shadow_resolution = Output.EnumConfigShadowResolution(self._io, self, self._root) if self.has_field_shadow_cascade_split_count: self.shadow_cascade_split_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_per_obj_shadow_quality: self.per_obj_shadow_quality = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shadow_blend: self.shadow_blend = self._io.read_u1() if self.has_field_per_object_pcf: self.per_object_pcf = self._io.read_u1() if self.has_field_enable_dynamic_shadow: self.enable_dynamic_shadow = self._io.read_u1() if self.has_field_enable_pcss: self.enable_pcss = self._io.read_u1() if self.has_field_enable_distant_shadow: self.enable_distant_shadow = self._io.read_u1() @property def has_field_enable_dynamic_shadow(self): if hasattr(self, '_m_has_field_enable_dynamic_shadow'): return self._m_has_field_enable_dynamic_shadow self._m_has_field_enable_dynamic_shadow = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_enable_dynamic_shadow', None) @property def has_field_shadow_cascade_split_count(self): if hasattr(self, '_m_has_field_shadow_cascade_split_count'): return self._m_has_field_shadow_cascade_split_count self._m_has_field_shadow_cascade_split_count = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shadow_cascade_split_count', None) @property def has_field_per_object_pcf(self): if hasattr(self, '_m_has_field_per_object_pcf'): return self._m_has_field_per_object_pcf self._m_has_field_per_object_pcf = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_per_object_pcf', None) @property def has_field_enable_distant_shadow(self): if hasattr(self, '_m_has_field_enable_distant_shadow'): return self._m_has_field_enable_distant_shadow self._m_has_field_enable_distant_shadow = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enable_distant_shadow', None) @property def has_field_shadow_blend(self): if hasattr(self, '_m_has_field_shadow_blend'): return self._m_has_field_shadow_blend self._m_has_field_shadow_blend = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_shadow_blend', None) @property def has_field_shadow_resolution(self): if hasattr(self, '_m_has_field_shadow_resolution'): return self._m_has_field_shadow_resolution self._m_has_field_shadow_resolution = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_shadow_resolution', None) @property def has_field_per_obj_shadow_quality(self): if hasattr(self, '_m_has_field_per_obj_shadow_quality'): return self._m_has_field_per_obj_shadow_quality self._m_has_field_per_obj_shadow_quality = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_per_obj_shadow_quality', None) @property def has_field_enable_pcss(self): if hasattr(self, '_m_has_field_enable_pcss'): return self._m_has_field_enable_pcss self._m_has_field_enable_pcss = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enable_pcss', None) @property def has_field_shadow_distance(self): if hasattr(self, '_m_has_field_shadow_distance'): return self._m_has_field_shadow_distance self._m_has_field_shadow_distance = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_shadow_distance', None) class LanV2projectionLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_silhouette: self.icon_silhouette = AuxTypes.String(self._io, self, self._root) if self.has_field_icon_normal: self.icon_normal = AuxTypes.String(self._io, self, self._root) if self.has_field_end_dialog_icon_offset_x: self.end_dialog_icon_offset_x = self._io.read_f4le() if self.has_field_end_dialog_icon_offset_y: self.end_dialog_icon_offset_y = self._io.read_f4le() if self.has_field_end_dialog_icon_scale: self.end_dialog_icon_scale = self._io.read_f4le() if self.has_field_scene_suite_id: self.scene_suite_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_root_point_switch_button_config_id: self.root_point_switch_button_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_root_point_correct_pose: self.root_point_correct_pose = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_root_point_initial_pose: self.root_point_initial_pose = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_root_point_motion_type: self.root_point_motion_type = Output.EnumLanV2projectionRootPointMotionType(self._io, self, self._root) if self.has_field_root_point_free_rotation_tolerance: self.root_point_free_rotation_tolerance = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_root_point_single_axis_rotation_axis: self.root_point_single_axis_rotation_axis = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_root_point_single_axis_rotation_limit: self.root_point_single_axis_rotation_limit = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_root_point_single_axis_rotation_tolerance: self.root_point_single_axis_rotation_tolerance = self._io.read_f4le() if self.has_field_hierarchy: self.hierarchy = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) if self.has_field_element_configs: self.element_configs = Output.ArrayOfLanV2projectionElementConfigLengthS(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_end_dialog_icon_offset_y(self): if hasattr(self, '_m_has_field_end_dialog_icon_offset_y'): return self._m_has_field_end_dialog_icon_offset_y self._m_has_field_end_dialog_icon_offset_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_end_dialog_icon_offset_y', None) @property def has_field_element_configs(self): if hasattr(self, '_m_has_field_element_configs'): return self._m_has_field_element_configs self._m_has_field_element_configs = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_element_configs', None) @property def has_field_icon_normal(self): if hasattr(self, '_m_has_field_icon_normal'): return self._m_has_field_icon_normal self._m_has_field_icon_normal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon_normal', None) @property def has_field_root_point_single_axis_rotation_limit(self): if hasattr(self, '_m_has_field_root_point_single_axis_rotation_limit'): return self._m_has_field_root_point_single_axis_rotation_limit self._m_has_field_root_point_single_axis_rotation_limit = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_root_point_single_axis_rotation_limit', None) @property def has_field_end_dialog_icon_offset_x(self): if hasattr(self, '_m_has_field_end_dialog_icon_offset_x'): return self._m_has_field_end_dialog_icon_offset_x self._m_has_field_end_dialog_icon_offset_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_end_dialog_icon_offset_x', None) @property def has_field_scene_suite_id(self): if hasattr(self, '_m_has_field_scene_suite_id'): return self._m_has_field_scene_suite_id self._m_has_field_scene_suite_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_scene_suite_id', None) @property def has_field_root_point_motion_type(self): if hasattr(self, '_m_has_field_root_point_motion_type'): return self._m_has_field_root_point_motion_type self._m_has_field_root_point_motion_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_root_point_motion_type', None) @property def has_field_root_point_single_axis_rotation_axis(self): if hasattr(self, '_m_has_field_root_point_single_axis_rotation_axis'): return self._m_has_field_root_point_single_axis_rotation_axis self._m_has_field_root_point_single_axis_rotation_axis = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_root_point_single_axis_rotation_axis', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_hierarchy(self): if hasattr(self, '_m_has_field_hierarchy'): return self._m_has_field_hierarchy self._m_has_field_hierarchy = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_hierarchy', None) @property def has_field_root_point_correct_pose(self): if hasattr(self, '_m_has_field_root_point_correct_pose'): return self._m_has_field_root_point_correct_pose self._m_has_field_root_point_correct_pose = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_root_point_correct_pose', None) @property def has_field_root_point_switch_button_config_id(self): if hasattr(self, '_m_has_field_root_point_switch_button_config_id'): return self._m_has_field_root_point_switch_button_config_id self._m_has_field_root_point_switch_button_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_root_point_switch_button_config_id', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_root_point_initial_pose(self): if hasattr(self, '_m_has_field_root_point_initial_pose'): return self._m_has_field_root_point_initial_pose self._m_has_field_root_point_initial_pose = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_root_point_initial_pose', None) @property def has_field_end_dialog_icon_scale(self): if hasattr(self, '_m_has_field_end_dialog_icon_scale'): return self._m_has_field_end_dialog_icon_scale self._m_has_field_end_dialog_icon_scale = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_end_dialog_icon_scale', None) @property def has_field_icon_silhouette(self): if hasattr(self, '_m_has_field_icon_silhouette'): return self._m_has_field_icon_silhouette self._m_has_field_icon_silhouette = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon_silhouette', None) @property def has_field_root_point_free_rotation_tolerance(self): if hasattr(self, '_m_has_field_root_point_free_rotation_tolerance'): return self._m_has_field_root_point_free_rotation_tolerance self._m_has_field_root_point_free_rotation_tolerance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_root_point_free_rotation_tolerance', None) @property def has_field_root_point_single_axis_rotation_tolerance(self): if hasattr(self, '_m_has_field_root_point_single_axis_rotation_tolerance'): return self._m_has_field_root_point_single_axis_rotation_tolerance self._m_has_field_root_point_single_axis_rotation_tolerance = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_root_point_single_axis_rotation_tolerance', None) class TriggerSkillRadialBlurMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class FishSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_category: self.skill_category = Output.EnumFishSkillCategory(self._io, self, self._root) if self.has_field_skill_type: self.skill_type = Output.EnumFishSkillType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_strength: self.strength = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_force_factor: self.force_factor = self._io.read_f4le() if self.has_field_bonus_width: self.bonus_width = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_bonus_duration: self.bonus_duration = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_bonus_offset: self.bonus_offset = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bonus_speed: self.bonus_speed = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bonus_duration(self): if hasattr(self, '_m_has_field_bonus_duration'): return self._m_has_field_bonus_duration self._m_has_field_bonus_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_bonus_duration', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_skill_category(self): if hasattr(self, '_m_has_field_skill_category'): return self._m_has_field_skill_category self._m_has_field_skill_category = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_category', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_skill_type(self): if hasattr(self, '_m_has_field_skill_type'): return self._m_has_field_skill_type self._m_has_field_skill_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_skill_type', None) @property def has_field_bonus_width(self): if hasattr(self, '_m_has_field_bonus_width'): return self._m_has_field_bonus_width self._m_has_field_bonus_width = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_bonus_width', None) @property def has_field_bonus_speed(self): if hasattr(self, '_m_has_field_bonus_speed'): return self._m_has_field_bonus_speed self._m_has_field_bonus_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_bonus_speed', None) @property def has_field_force_factor(self): if hasattr(self, '_m_has_field_force_factor'): return self._m_has_field_force_factor self._m_has_field_force_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_force_factor', None) @property def has_field_strength(self): if hasattr(self, '_m_has_field_strength'): return self._m_has_field_strength self._m_has_field_strength = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_strength', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_duration', None) @property def has_field_bonus_offset(self): if hasattr(self, '_m_has_field_bonus_offset'): return self._m_has_field_bonus_offset self._m_has_field_bonus_offset = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_bonus_offset', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class AudioImpactOverrideEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_id: self.entity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_impact_event: self.impact_event = Output.AudioOneTimeEvent(self._io, self, self._root) @property def has_field_entity_id(self): if hasattr(self, '_m_has_field_entity_id'): return self._m_has_field_entity_id self._m_has_field_entity_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_id', None) @property def has_field_impact_event(self): if hasattr(self, '_m_has_field_impact_event'): return self._m_has_field_impact_event self._m_has_field_impact_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_impact_event', None) class ArrayOfDvalinS01pathEffsInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DvalinS01pathEffsInfo(self._io, self, self._root)) class EnumLoadingTipsSituationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LoadingTipsSituationType, self.data.value) return getattr(self, '_m_value', None) class TryFindMotionChangePosByBorn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_set_target: self.set_target = self._io.read_u1() if self.has_field_hit_scene_test: self.hit_scene_test = self._io.read_u1() if self.has_field_limit_y: self.limit_y = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_ignore_water: self.ignore_water = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_target(self): if hasattr(self, '_m_has_field_set_target'): return self._m_has_field_set_target self._m_has_field_set_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_hit_scene_test(self): if hasattr(self, '_m_has_field_hit_scene_test'): return self._m_has_field_hit_scene_test self._m_has_field_hit_scene_test = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_hit_scene_test', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_limit_y(self): if hasattr(self, '_m_has_field_limit_y'): return self._m_has_field_limit_y self._m_has_field_limit_y = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_limit_y', None) @property def has_field_ignore_water(self): if hasattr(self, '_m_has_field_ignore_water'): return self._m_has_field_ignore_water self._m_has_field_ignore_water = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_ignore_water', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class RandTaskContentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfGradeItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_device_spec_item: self.device_spec_item = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeS(self._io, self, self._root) if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfGradeItemOptionArrayInfo(self._io, self, self._root) if self.has_field_override_map: self.override_map = Output.DictOfAuxTypesStringConfigPerfGradeItemOverrideInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def has_field_override_map(self): if hasattr(self, '_m_has_field_override_map'): return self._m_has_field_override_map self._m_has_field_override_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map', None) @property def has_field_device_spec_item(self): if hasattr(self, '_m_has_field_device_spec_item'): return self._m_has_field_device_spec_item self._m_has_field_device_spec_item = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_device_spec_item', None) class ConfigMusicDoubleLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class FishStockExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuideAvatarAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideAvatarAction, self.data.value) return getattr(self, '_m_value', None) class EnumConcernType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConcernType, self.data.value) return getattr(self, '_m_value', None) class LandSoundExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_audio_name: self.audio_name = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_audio_name(self): if hasattr(self, '_m_has_field_audio_name'): return self._m_has_field_audio_name self._m_has_field_audio_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_audio_name', None) class ConfigGuideOpenStateCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_open_state: self.open_state = Output.EnumGuideOpenStateType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_open_state', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumMpPlaySettleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MpPlaySettleType, self.data.value) return getattr(self, '_m_value', None) class WeaponPromoteExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_weapon_promote_id: self.weapon_promote_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_promote_level: self.promote_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_coin_cost: self.coin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_unlock_max_level: self.unlock_max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_required_player_level: self.required_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_required_player_level(self): if hasattr(self, '_m_has_field_required_player_level'): return self._m_has_field_required_player_level self._m_has_field_required_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_required_player_level', None) @property def has_field_coin_cost(self): if hasattr(self, '_m_has_field_coin_cost'): return self._m_has_field_coin_cost self._m_has_field_coin_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_coin_cost', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_promote_level(self): if hasattr(self, '_m_has_field_promote_level'): return self._m_has_field_promote_level self._m_has_field_promote_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_promote_level', None) @property def has_field_unlock_max_level(self): if hasattr(self, '_m_has_field_unlock_max_level'): return self._m_has_field_unlock_max_level self._m_has_field_unlock_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_unlock_max_level', None) @property def has_field_weapon_promote_id(self): if hasattr(self, '_m_has_field_weapon_promote_id'): return self._m_has_field_weapon_promote_id self._m_has_field_weapon_promote_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_weapon_promote_id', None) class DailyTaskExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySumoOverallConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prerequisite_quest_id: self.prerequisite_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lead_quest_id: self.lead_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_watcher_id: self.global_watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_team_num: self.team_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_team_member_num: self.max_team_member_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_team_selectable_skill_num: self.team_selectable_skill_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_switch_team_cd: self.switch_team_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_max_team_member_num(self): if hasattr(self, '_m_has_field_max_team_member_num'): return self._m_has_field_max_team_member_num self._m_has_field_max_team_member_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_max_team_member_num', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_prerequisite_quest_id(self): if hasattr(self, '_m_has_field_prerequisite_quest_id'): return self._m_has_field_prerequisite_quest_id self._m_has_field_prerequisite_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_prerequisite_quest_id', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_lead_quest_id(self): if hasattr(self, '_m_has_field_lead_quest_id'): return self._m_has_field_lead_quest_id self._m_has_field_lead_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_lead_quest_id', None) @property def has_field_team_selectable_skill_num(self): if hasattr(self, '_m_has_field_team_selectable_skill_num'): return self._m_has_field_team_selectable_skill_num self._m_has_field_team_selectable_skill_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_team_selectable_skill_num', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_switch_team_cd(self): if hasattr(self, '_m_has_field_switch_team_cd'): return self._m_has_field_switch_team_cd self._m_has_field_switch_team_cd = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_switch_team_cd', None) @property def has_field_global_watcher_id(self): if hasattr(self, '_m_has_field_global_watcher_id'): return self._m_has_field_global_watcher_id self._m_has_field_global_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_global_watcher_id', None) @property def has_field_team_num(self): if hasattr(self, '_m_has_field_team_num'): return self._m_has_field_team_num self._m_has_field_team_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_team_num', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigBattleFervorUpdateTriggerByMonster(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_combat_bgm_level: self.combat_bgm_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_combat_bgm_level(self): if hasattr(self, '_m_has_field_combat_bgm_level'): return self._m_has_field_combat_bgm_level self._m_has_field_combat_bgm_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_combat_bgm_level', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class HuntingRegionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ScoreEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_prefix_root_name: self.prefix_root_name = AuxTypes.String(self._io, self, self._root) if self.has_field_root_name_key: self.root_name_key = AuxTypes.String(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_prefix_root_name(self): if hasattr(self, '_m_has_field_prefix_root_name'): return self._m_has_field_prefix_root_name self._m_has_field_prefix_root_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_prefix_root_name', None) @property def has_field_root_name_key(self): if hasattr(self, '_m_has_field_root_name_key'): return self._m_has_field_root_name_key self._m_has_field_root_name_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_root_name_key', None) class KvpOfDictAuxTypesStringConfigPerfStringKeyItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfStringKeyItemOverrideInfo(self._io, self, self._root) class EnumGuideCmdType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideCmdType, self.data.value) return getattr(self, '_m_value', None) class ConfigMist(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hide_scene_point_list: self.hide_scene_point_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_map_pos_list: self.map_pos_list = Output.ArrayOfPoint2dLengthU(self._io, self, self._root) if self.has_field_need_anim: self.need_anim = self._io.read_u1() if self.has_field_show_unlock_scene_point: self.show_unlock_scene_point = self._io.read_u1() @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sort_id', None) @property def has_field_show_unlock_scene_point(self): if hasattr(self, '_m_has_field_show_unlock_scene_point'): return self._m_has_field_show_unlock_scene_point self._m_has_field_show_unlock_scene_point = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_show_unlock_scene_point', None) @property def has_field_map_pos_list(self): if hasattr(self, '_m_has_field_map_pos_list'): return self._m_has_field_map_pos_list self._m_has_field_map_pos_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_map_pos_list', None) @property def has_field_hide_scene_point_list(self): if hasattr(self, '_m_has_field_hide_scene_point_list'): return self._m_has_field_hide_scene_point_list self._m_has_field_hide_scene_point_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hide_scene_point_list', None) @property def has_field_need_anim(self): if hasattr(self, '_m_has_field_need_anim'): return self._m_has_field_need_anim self._m_has_field_need_anim = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_need_anim', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_prefab_path', None) class VoiceTriggerIdentity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_game_trigger: self.game_trigger = Output.EnumAudioVoiceTrigger(self._io, self, self._root) if self.has_field_game_trigger_args: self.game_trigger_args = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_game_trigger(self): if hasattr(self, '_m_has_field_game_trigger'): return self._m_has_field_game_trigger self._m_has_field_game_trigger = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_game_trigger', None) @property def has_field_game_trigger_args(self): if hasattr(self, '_m_has_field_game_trigger_args'): return self._m_has_field_game_trigger_args self._m_has_field_game_trigger_args = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_game_trigger_args', None) class ByIsTargetCamp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camp_base_on: self.camp_base_on = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) @property def has_field_camp_base_on(self): if hasattr(self, '_m_has_field_camp_base_on'): return self._m_has_field_camp_base_on self._m_has_field_camp_base_on = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camp_base_on', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumInputActionGroupType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InputActionGroupType, self.data.value) return getattr(self, '_m_value', None) class ActivityGearJigsawExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_place_pos_select_effect: self.place_pos_select_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_cover_up_effect: self.cover_up_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_rotate_effect: self.rotate_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_quest_state_trigger_id: self.quest_state_trigger_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_rotate_effect(self): if hasattr(self, '_m_has_field_rotate_effect'): return self._m_has_field_rotate_effect self._m_has_field_rotate_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_rotate_effect', None) @property def has_field_place_pos_select_effect(self): if hasattr(self, '_m_has_field_place_pos_select_effect'): return self._m_has_field_place_pos_select_effect self._m_has_field_place_pos_select_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_place_pos_select_effect', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_quest_state_trigger_id(self): if hasattr(self, '_m_has_field_quest_state_trigger_id'): return self._m_has_field_quest_state_trigger_id self._m_has_field_quest_state_trigger_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_state_trigger_id', None) @property def has_field_cover_up_effect(self): if hasattr(self, '_m_has_field_cover_up_effect'): return self._m_has_field_cover_up_effect self._m_has_field_cover_up_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cover_up_effect', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ArrayOfEnumInputActionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumInputActionType(self._io, self, self._root)) class HuntingClueTextExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumJsonClimateTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumJsonClimateType(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class ConfigBattleFervorUpdatePredicateFactorRange(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdatePredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_min: self.min = self._io.read_f4le() if self.has_field_max: self.max = self._io.read_f4le() @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max', None) class DispConfigBornDirectionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 10: self.data = Output.ConfigDirectionByWorld(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBornDirectionType(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigDirectionByAttachPoint(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigDirectionByLookAtEntity(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigDirectionByLookAtEntityFix(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigDirectionByDefault(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigDirectionByRefraction(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigDirectionByGroundNormalRange(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigDirectionByReflection(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigDirectionByAttackTarget(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigDirectionByBackToHitBoxCenter(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigDirectionByGroundNormal(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigDirectionByGlobalValue(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigDirectionByEntity(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class LayeredSamplingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vertices: self.vertices = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_masks: self.masks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_vertices(self): if hasattr(self, '_m_has_field_vertices'): return self._m_has_field_vertices self._m_has_field_vertices = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_vertices', None) @property def has_field_masks(self): if hasattr(self, '_m_has_field_masks'): return self._m_has_field_masks self._m_has_field_masks = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_masks', None) class AttachLight(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attach: self.attach = Output.ConfigLightAttach(self._io, self, self._root) if self.has_field_light: self.light = Output.ConfigLightComponent(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_attach(self): if hasattr(self, '_m_has_field_attach'): return self._m_has_field_attach self._m_has_field_attach = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_light(self): if hasattr(self, '_m_has_field_light'): return self._m_has_field_light self._m_has_field_light = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_light', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class AbilityOverrideExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_special_param_config: self.ability_special_param_config = Output.ArrayOfAbilityOverrideParamConfigLengthS(self._io, self, self._root) if self.has_field_param_name_list: self.param_name_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_param_value_list: self.param_value_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_reset_ability_special: self.reset_ability_special = self._io.read_u1() @property def has_field_reset_ability_special(self): if hasattr(self, '_m_has_field_reset_ability_special'): return self._m_has_field_reset_ability_special self._m_has_field_reset_ability_special = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reset_ability_special', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_param_value_list(self): if hasattr(self, '_m_has_field_param_value_list'): return self._m_has_field_param_value_list self._m_has_field_param_value_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_param_value_list', None) @property def has_field_ability_special_param_config(self): if hasattr(self, '_m_has_field_ability_special_param_config'): return self._m_has_field_ability_special_param_config self._m_has_field_ability_special_param_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ability_special_param_config', None) @property def has_field_param_name_list(self): if hasattr(self, '_m_has_field_param_name_list'): return self._m_has_field_param_name_list self._m_has_field_param_name_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param_name_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class AddGlobalValueToTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_src_target: self.src_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_dst_target: self.dst_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_src_key: self.src_key = AuxTypes.String(self._io, self, self._root) if self.has_field_dst_key: self.dst_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_src_key(self): if hasattr(self, '_m_has_field_src_key'): return self._m_has_field_src_key self._m_has_field_src_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_src_key', None) @property def has_field_dst_target(self): if hasattr(self, '_m_has_field_dst_target'): return self._m_has_field_dst_target self._m_has_field_dst_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dst_target', None) @property def has_field_dst_key(self): if hasattr(self, '_m_has_field_dst_key'): return self._m_has_field_dst_key self._m_has_field_dst_key = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_dst_key', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_src_target(self): if hasattr(self, '_m_has_field_src_target'): return self._m_has_field_src_target self._m_has_field_src_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_src_target', None) class ConfigWidgetToyMiracleRing(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_allowed_in_dungeon: self.is_allowed_in_dungeon = self._io.read_u1() if self.has_field_is_allowed_in_room: self.is_allowed_in_room = self._io.read_u1() if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_create_gadget_id: self.create_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_combat_destroy_distance: self.combat_destroy_distance = self._io.read_f4le() @property def has_field_is_allowed_in_dungeon(self): if hasattr(self, '_m_has_field_is_allowed_in_dungeon'): return self._m_has_field_is_allowed_in_dungeon self._m_has_field_is_allowed_in_dungeon = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_allowed_in_dungeon', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_is_allowed_in_room(self): if hasattr(self, '_m_has_field_is_allowed_in_room'): return self._m_has_field_is_allowed_in_room self._m_has_field_is_allowed_in_room = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_allowed_in_room', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_combat_destroy_distance(self): if hasattr(self, '_m_has_field_combat_destroy_distance'): return self._m_has_field_combat_destroy_distance self._m_has_field_combat_destroy_distance = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_combat_destroy_distance', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_create_gadget_id(self): if hasattr(self, '_m_has_field_create_gadget_id'): return self._m_has_field_create_gadget_id self._m_has_field_create_gadget_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_create_gadget_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class ActivitySumoOverallConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFurnitureDeploySurfaceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FurnitureDeploySurfaceType, self.data.value) return getattr(self, '_m_value', None) class ActivityChessPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_main_id: self.pre_quest_main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_quest_main_id: self.open_quest_main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_match_player_limit: self.match_player_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_teach_dungeon: self.open_teach_dungeon = self._io.read_u1() if self.has_field_teach_dungeon_id: self.teach_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_teach_map_id: self.teach_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_punish_time: self.punish_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_id: self.coin_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series_id: self.series_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_teach_score_id_list: self.teach_score_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_teach_map_id(self): if hasattr(self, '_m_has_field_teach_map_id'): return self._m_has_field_teach_map_id self._m_has_field_teach_map_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_teach_map_id', None) @property def has_field_pre_quest_main_id(self): if hasattr(self, '_m_has_field_pre_quest_main_id'): return self._m_has_field_pre_quest_main_id self._m_has_field_pre_quest_main_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pre_quest_main_id', None) @property def has_field_match_player_limit(self): if hasattr(self, '_m_has_field_match_player_limit'): return self._m_has_field_match_player_limit self._m_has_field_match_player_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_match_player_limit', None) @property def has_field_punish_time(self): if hasattr(self, '_m_has_field_punish_time'): return self._m_has_field_punish_time self._m_has_field_punish_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_punish_time', None) @property def has_field_open_teach_dungeon(self): if hasattr(self, '_m_has_field_open_teach_dungeon'): return self._m_has_field_open_teach_dungeon self._m_has_field_open_teach_dungeon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_open_teach_dungeon', None) @property def has_field_coin_id(self): if hasattr(self, '_m_has_field_coin_id'): return self._m_has_field_coin_id self._m_has_field_coin_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_coin_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_teach_score_id_list(self): if hasattr(self, '_m_has_field_teach_score_id_list'): return self._m_has_field_teach_score_id_list self._m_has_field_teach_score_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_teach_score_id_list', None) @property def has_field_open_quest_main_id(self): if hasattr(self, '_m_has_field_open_quest_main_id'): return self._m_has_field_open_quest_main_id self._m_has_field_open_quest_main_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_open_quest_main_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_teach_dungeon_id(self): if hasattr(self, '_m_has_field_teach_dungeon_id'): return self._m_has_field_teach_dungeon_id self._m_has_field_teach_dungeon_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_teach_dungeon_id', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_series_id(self): if hasattr(self, '_m_has_field_series_id'): return self._m_has_field_series_id self._m_has_field_series_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_series_id', None) class GatherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PaimonSkillComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideAvatarActionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityDeliveryWatcherDataConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_trigger_config', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_disuse', None) class ExhibitionListExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_default_show: self.default_show = self._io.read_u1() if self.has_field_display_id: self.display_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series_id: self.series_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_title: self.display_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_format: self.display_format = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_type: self.display_type = Output.EnumExhibitionListDisplayType(self._io, self, self._root) @property def has_field_display_title(self): if hasattr(self, '_m_has_field_display_title'): return self._m_has_field_display_title self._m_has_field_display_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_display_title', None) @property def has_field_display_format(self): if hasattr(self, '_m_has_field_display_format'): return self._m_has_field_display_format self._m_has_field_display_format = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_display_format', None) @property def has_field_display_type(self): if hasattr(self, '_m_has_field_display_type'): return self._m_has_field_display_type self._m_has_field_display_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_display_type', None) @property def has_field_display_id(self): if hasattr(self, '_m_has_field_display_id'): return self._m_has_field_display_id self._m_has_field_display_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_display_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_default_show(self): if hasattr(self, '_m_has_field_default_show'): return self._m_has_field_default_show self._m_has_field_default_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_default_show', None) @property def has_field_series_id(self): if hasattr(self, '_m_has_field_series_id'): return self._m_has_field_series_id self._m_has_field_series_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_series_id', None) class RewardSourceSystemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeaponProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_init_value: self.init_value = self._io.read_f4le() if self.has_field_type: self.type = Output.EnumGrowCurveType(self._io, self, self._root) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prop_type', None) @property def has_field_init_value(self): if hasattr(self, '_m_has_field_init_value'): return self._m_has_field_init_value self._m_has_field_init_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_init_value', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_type', None) class EnumNeuronMixinRemoveOperatorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NeuronMixinRemoveOperatorType, self.data.value) return getattr(self, '_m_value', None) class ConfigLogoPageSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_config: self.default_config = Output.ConfigLogoPage(self._io, self, self._root) if self.has_field_logo_config_map: self.logo_config_map = Output.DictOfAuxTypesStringConfigLogoPage(self._io, self, self._root) if self.has_field_logo_folder_path: self.logo_folder_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tip_img_aw_folder_path: self.tip_img_aw_folder_path = AuxTypes.String(self._io, self, self._root) @property def has_field_default_config(self): if hasattr(self, '_m_has_field_default_config'): return self._m_has_field_default_config self._m_has_field_default_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_config', None) @property def has_field_logo_config_map(self): if hasattr(self, '_m_has_field_logo_config_map'): return self._m_has_field_logo_config_map self._m_has_field_logo_config_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logo_config_map', None) @property def has_field_logo_folder_path(self): if hasattr(self, '_m_has_field_logo_folder_path'): return self._m_has_field_logo_folder_path self._m_has_field_logo_folder_path = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logo_folder_path', None) @property def has_field_tip_img_aw_folder_path(self): if hasattr(self, '_m_has_field_tip_img_aw_folder_path'): return self._m_has_field_tip_img_aw_folder_path self._m_has_field_tip_img_aw_folder_path = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_tip_img_aw_folder_path', None) class ConfigMusicSyncTransitions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_beat_transitions: self.beat_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_bar_transitions: self.bar_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_grid_transitions: self.grid_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_cue_transitions: self.cue_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_exit_transitions: self.exit_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) @property def has_field_grid_transitions(self): if hasattr(self, '_m_has_field_grid_transitions'): return self._m_has_field_grid_transitions self._m_has_field_grid_transitions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_grid_transitions', None) @property def has_field_bar_transitions(self): if hasattr(self, '_m_has_field_bar_transitions'): return self._m_has_field_bar_transitions self._m_has_field_bar_transitions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bar_transitions', None) @property def has_field_beat_transitions(self): if hasattr(self, '_m_has_field_beat_transitions'): return self._m_has_field_beat_transitions self._m_has_field_beat_transitions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_beat_transitions', None) @property def has_field_exit_transitions(self): if hasattr(self, '_m_has_field_exit_transitions'): return self._m_has_field_exit_transitions self._m_has_field_exit_transitions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_exit_transitions', None) @property def has_field_cue_transitions(self): if hasattr(self, '_m_has_field_cue_transitions'): return self._m_has_field_cue_transitions self._m_has_field_cue_transitions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cue_transitions', None) class ByCurTeamBodyTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class UnlockControllerConditions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_condition_name: self.condition_name = AuxTypes.String(self._io, self, self._root) @property def has_field_condition_name(self): if hasattr(self, '_m_has_field_condition_name'): return self._m_has_field_condition_name self._m_has_field_condition_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_condition_name', None) class EnumExploreType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExploreType, self.data.value) return getattr(self, '_m_value', None) class ConfigWidgetClientDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_allow_city_id: self.allow_city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_hint_group', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_height', None) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_allow_city_id(self): if hasattr(self, '_m_has_field_allow_city_id'): return self._m_has_field_allow_city_id self._m_has_field_allow_city_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_allow_city_id', None) class GuidePlatformComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalentFilterCondComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_quests: self.quests = Output.ArrayOfConfigAudioQuestOpsLengthU(self._io, self, self._root) @property def has_field_quests(self): if hasattr(self, '_m_has_field_quests'): return self._m_has_field_quests self._m_has_field_quests = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quests', None) class ConfigCameraSplineBezierTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBaseTarget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_in_control_point: self.in_control_point = Output.Vector(self._io, self, self._root) if self.has_field_out_control_point: self.out_control_point = Output.Vector(self._io, self, self._root) @property def t_list(self): if hasattr(self, '_m_t_list'): return self._m_t_list self._m_t_list = self.base.t_list return getattr(self, '_m_t_list', None) @property def position(self): if hasattr(self, '_m_position'): return self._m_position self._m_position = self.base.position return getattr(self, '_m_position', None) @property def s_list(self): if hasattr(self, '_m_s_list'): return self._m_s_list self._m_s_list = self.base.s_list return getattr(self, '_m_s_list', None) @property def length_ratio(self): if hasattr(self, '_m_length_ratio'): return self._m_length_ratio self._m_length_ratio = self.base.length_ratio return getattr(self, '_m_length_ratio', None) @property def has_field_in_control_point(self): if hasattr(self, '_m_has_field_in_control_point'): return self._m_has_field_in_control_point self._m_has_field_in_control_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_in_control_point', None) @property def has_field_out_control_point(self): if hasattr(self, '_m_has_field_out_control_point'): return self._m_has_field_out_control_point self._m_has_field_out_control_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_out_control_point', None) class EnumRogueDiaryTiredType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueDiaryTiredType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfElementBatchPredicatedLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ElementBatchPredicated(self._io, self, self._root)) class SectrAttachStreamLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attach_name_hash: self.attach_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_festival_layer_path_info: self.festival_layer_path_info = Output.SectrCombineStreamPathInfo(self._io, self, self._root) if self.has_field_routine_layer_path_info: self.routine_layer_path_info = Output.SectrCombineStreamPathInfo(self._io, self, self._root) @property def has_field_attach_name_hash(self): if hasattr(self, '_m_has_field_attach_name_hash'): return self._m_has_field_attach_name_hash self._m_has_field_attach_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_name_hash', None) @property def has_field_festival_layer_path_info(self): if hasattr(self, '_m_has_field_festival_layer_path_info'): return self._m_has_field_festival_layer_path_info self._m_has_field_festival_layer_path_info = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_festival_layer_path_info', None) @property def has_field_routine_layer_path_info(self): if hasattr(self, '_m_has_field_routine_layer_path_info'): return self._m_has_field_routine_layer_path_info self._m_has_field_routine_layer_path_info = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_routine_layer_path_info', None) class ConfigCharacterRendering(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_override_light_dir: self.override_light_dir = self._io.read_u1() if self.has_field_override_light_euler_angle: self.override_light_euler_angle = Output.Vector(self._io, self, self._root) @property def has_field_override_light_dir(self): if hasattr(self, '_m_has_field_override_light_dir'): return self._m_has_field_override_light_dir self._m_has_field_override_light_dir = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_light_dir', None) @property def has_field_override_light_euler_angle(self): if hasattr(self, '_m_has_field_override_light_euler_angle'): return self._m_has_field_override_light_euler_angle self._m_has_field_override_light_euler_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_override_light_euler_angle', None) class MpPlayWatcherConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mp_play_id: self.mp_play_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_store: self.is_store = self._io.read_u1() if self.has_field_challenge_desc: self.challenge_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_title: self.challenge_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_challenge_title(self): if hasattr(self, '_m_has_field_challenge_title'): return self._m_has_field_challenge_title self._m_has_field_challenge_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_challenge_title', None) @property def has_field_is_store(self): if hasattr(self, '_m_has_field_is_store'): return self._m_has_field_is_store self._m_has_field_is_store = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_store', None) @property def has_field_mp_play_id(self): if hasattr(self, '_m_has_field_mp_play_id'): return self._m_has_field_mp_play_id self._m_has_field_mp_play_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mp_play_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_challenge_desc(self): if hasattr(self, '_m_has_field_challenge_desc'): return self._m_has_field_challenge_desc self._m_has_field_challenge_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_challenge_desc', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ConfigLMapMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLBaseMark(self._io, self, self._root) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def views(self): if hasattr(self, '_m_views'): return self._m_views self._m_views = self.base.views return getattr(self, '_m_views', None) class ActivityArenaChallengeChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_start_day: self.chapter_start_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_start_quest_id: self.chapter_start_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_end_quest_id: self.chapter_end_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_quest_title: self.chapter_quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_quest_desc: self.chapter_quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_chapter_end_quest_id(self): if hasattr(self, '_m_has_field_chapter_end_quest_id'): return self._m_has_field_chapter_end_quest_id self._m_has_field_chapter_end_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_chapter_end_quest_id', None) @property def has_field_chapter_quest_title(self): if hasattr(self, '_m_has_field_chapter_quest_title'): return self._m_has_field_chapter_quest_title self._m_has_field_chapter_quest_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_chapter_quest_title', None) @property def has_field_chapter_start_quest_id(self): if hasattr(self, '_m_has_field_chapter_start_quest_id'): return self._m_has_field_chapter_start_quest_id self._m_has_field_chapter_start_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_start_quest_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_chapter_quest_desc(self): if hasattr(self, '_m_has_field_chapter_quest_desc'): return self._m_has_field_chapter_quest_desc self._m_has_field_chapter_quest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_chapter_quest_desc', None) @property def has_field_chapter_start_day(self): if hasattr(self, '_m_has_field_chapter_start_day'): return self._m_has_field_chapter_start_day self._m_has_field_chapter_start_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_start_day', None) class EnumCreaterBornTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CreaterBornTag, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigPerfNumberArrayItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberArrayItem(self._io, self, self._root) class ConfigAiMixinSetInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_int_id: self.int_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_int_id(self): if hasattr(self, '_m_has_field_int_id'): return self._m_has_field_int_id self._m_has_field_int_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class EnumGlobalValueChangeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GlobalValueChangeType, self.data.value) return getattr(self, '_m_value', None) class SectrStreamObjectSerialize(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumSectrStreamObjectType(self._io, self, self._root) if self.has_field_game_object_path_hash: self.game_object_path_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_obj_pattern_name: self.obj_pattern_name = AuxTypes.String(self._io, self, self._root) if self.has_field_magitude: self.magitude = self._io.read_f4le() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_scale: self.scale = Output.Vector(self._io, self, self._root) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_game_object_path_hash(self): if hasattr(self, '_m_has_field_game_object_path_hash'): return self._m_has_field_game_object_path_hash self._m_has_field_game_object_path_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_game_object_path_hash', None) @property def has_field_obj_pattern_name(self): if hasattr(self, '_m_has_field_obj_pattern_name'): return self._m_has_field_obj_pattern_name self._m_has_field_obj_pattern_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_obj_pattern_name', None) @property def has_field_magitude(self): if hasattr(self, '_m_has_field_magitude'): return self._m_has_field_magitude self._m_has_field_magitude = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_magitude', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_scale', None) class ConfigGadgetDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class DictOfEnumTdPlayTowerTypeConfigTdPlayTowerData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumTdPlayTowerTypeConfigTdPlayTowerData(self._io, self, self._root)) class ConfigJudgeMoonOrSunInCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class LevelSuppressExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_level_suppress_damage_co: self.level_suppress_damage_co = self._io.read_f4le() if self.has_field_level_suppress_endure: self.level_suppress_endure = self._io.read_f4le() if self.has_field_level_suppress_dis_min_horizontal: self.level_suppress_dis_min_horizontal = self._io.read_f4le() if self.has_field_level_suppress_dis_max_horizontal: self.level_suppress_dis_max_horizontal = self._io.read_f4le() if self.has_field_level_suppress_dis_min_vertical: self.level_suppress_dis_min_vertical = self._io.read_f4le() if self.has_field_level_suppress_dis_max_vertical: self.level_suppress_dis_max_vertical = self._io.read_f4le() if self.has_field_is_attacker_player: self.is_attacker_player = self._io.read_u1() if self.has_field_is_defenser_player: self.is_defenser_player = self._io.read_u1() @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_level_suppress_dis_min_horizontal(self): if hasattr(self, '_m_has_field_level_suppress_dis_min_horizontal'): return self._m_has_field_level_suppress_dis_min_horizontal self._m_has_field_level_suppress_dis_min_horizontal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_suppress_dis_min_horizontal', None) @property def has_field_level_suppress_dis_max_vertical(self): if hasattr(self, '_m_has_field_level_suppress_dis_max_vertical'): return self._m_has_field_level_suppress_dis_max_vertical self._m_has_field_level_suppress_dis_max_vertical = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_level_suppress_dis_max_vertical', None) @property def has_field_level_suppress_damage_co(self): if hasattr(self, '_m_has_field_level_suppress_damage_co'): return self._m_has_field_level_suppress_damage_co self._m_has_field_level_suppress_damage_co = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_suppress_damage_co', None) @property def has_field_level_suppress_endure(self): if hasattr(self, '_m_has_field_level_suppress_endure'): return self._m_has_field_level_suppress_endure self._m_has_field_level_suppress_endure = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_suppress_endure', None) @property def has_field_is_attacker_player(self): if hasattr(self, '_m_has_field_is_attacker_player'): return self._m_has_field_is_attacker_player self._m_has_field_is_attacker_player = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_attacker_player', None) @property def has_field_level_suppress_dis_max_horizontal(self): if hasattr(self, '_m_has_field_level_suppress_dis_max_horizontal'): return self._m_has_field_level_suppress_dis_max_horizontal self._m_has_field_level_suppress_dis_max_horizontal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_suppress_dis_max_horizontal', None) @property def has_field_is_defenser_player(self): if hasattr(self, '_m_has_field_is_defenser_player'): return self._m_has_field_is_defenser_player self._m_has_field_is_defenser_player = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_defenser_player', None) @property def has_field_level_suppress_dis_min_vertical(self): if hasattr(self, '_m_has_field_level_suppress_dis_min_vertical'): return self._m_has_field_level_suppress_dis_min_vertical self._m_has_field_level_suppress_dis_min_vertical = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level_suppress_dis_min_vertical', None) class EnumSectrSectorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrSectorType, self.data.value) return getattr(self, '_m_value', None) class BartenderEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CustomLevelTagSortConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_color: self.color = AuxTypes.String(self._io, self, self._root) if self.has_field_end_color: self.end_color = AuxTypes.String(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_color(self): if hasattr(self, '_m_has_field_color'): return self._m_has_field_color self._m_has_field_color = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_color', None) @property def has_field_end_color(self): if hasattr(self, '_m_has_field_end_color'): return self._m_has_field_end_color self._m_has_field_end_color = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_end_color', None) class ByAnimatorFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_parameter', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumGuideItemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideItemType, self.data.value) return getattr(self, '_m_value', None) class LanV2overAllDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMaterialCodexType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MaterialCodexType, self.data.value) return getattr(self, '_m_value', None) class DungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_name: self.display_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDungeonType(self._io, self, self._root) if self.has_field_sub_type: self.sub_type = Output.EnumDungeonSubType(self._io, self, self._root) if self.has_field_is_dynamic_level: self.is_dynamic_level = self._io.read_u1() if self.has_field_serial_id: self.serial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumDungeonPlayType(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_event_interval: self.event_interval = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_involve_type: self.involve_type = Output.EnumInvolveType(self._io, self, self._root) if self.has_field_show_level: self.show_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_limit_type: self.avatar_limit_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_level: self.limit_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_revise: self.level_revise = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_prev_dungeon_id: self.prev_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_require_avatar_id: self.require_avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pass_cond: self.pass_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pass_jump_dungeon: self.pass_jump_dungeon = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revive_interval_time: self.revive_interval_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revive_max_count: self.revive_max_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_enter_count: self.day_enter_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enter_cost_items: self.enter_cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_first_pass_reward_preview_id: self.first_pass_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pass_reward_preview_id: self.pass_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_settle_countdown_time: self.settle_countdown_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fail_settle_countdown_time: self.fail_settle_countdown_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quit_settle_countdown_time: self.quit_settle_countdown_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_settle_shows: self.settle_shows = Output.ArrayOfEnumSettleShowTypeLengthS(self._io, self, self._root) if self.has_field_forbidden_restart: self.forbidden_restart = self._io.read_u1() if self.has_field_settle_ui_type: self.settle_ui_type = Output.EnumSettleUiType(self._io, self, self._root) if self.has_field_statue_cost_id: self.statue_cost_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_statue_cost_count: self.statue_cost_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_statue_drop: self.statue_drop = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recommend_element_types: self.recommend_element_types = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_recommend_tips: self.recommend_tips = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_config_map: self.level_config_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_preview_monster_list: self.preview_monster_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gear_desc: self.gear_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dont_show_push_tips: self.dont_show_push_tips = self._io.read_u1() if self.has_field_entry_pic_path: self.entry_pic_path = AuxTypes.String(self._io, self, self._root) if self.has_field_state_type: self.state_type = Output.EnumDungeonStateType(self._io, self, self._root) if self.has_field_factor_pic: self.factor_pic = AuxTypes.String(self._io, self, self._root) if self.has_field_factor_icon: self.factor_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_enable_quest_guide: self.enable_quest_guide = self._io.read_u1() @property def has_field_require_avatar_id(self): if hasattr(self, '_m_has_field_require_avatar_id'): return self._m_has_field_require_avatar_id self._m_has_field_require_avatar_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_require_avatar_id', None) @property def has_field_avatar_limit_type(self): if hasattr(self, '_m_has_field_avatar_limit_type'): return self._m_has_field_avatar_limit_type self._m_has_field_avatar_limit_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_avatar_limit_type', None) @property def has_field_statue_drop(self): if hasattr(self, '_m_has_field_statue_drop'): return self._m_has_field_statue_drop self._m_has_field_statue_drop = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 4) != 0)) return getattr(self, '_m_has_field_statue_drop', None) @property def has_field_statue_cost_count(self): if hasattr(self, '_m_has_field_statue_cost_count'): return self._m_has_field_statue_cost_count self._m_has_field_statue_cost_count = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_statue_cost_count', None) @property def has_field_preview_monster_list(self): if hasattr(self, '_m_has_field_preview_monster_list'): return self._m_has_field_preview_monster_list self._m_has_field_preview_monster_list = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 64) != 0)) return getattr(self, '_m_has_field_preview_monster_list', None) @property def has_field_settle_shows(self): if hasattr(self, '_m_has_field_settle_shows'): return self._m_has_field_settle_shows self._m_has_field_settle_shows = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_settle_shows', None) @property def has_field_pass_cond(self): if hasattr(self, '_m_has_field_pass_cond'): return self._m_has_field_pass_cond self._m_has_field_pass_cond = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_pass_cond', None) @property def has_field_quit_settle_countdown_time(self): if hasattr(self, '_m_has_field_quit_settle_countdown_time'): return self._m_has_field_quit_settle_countdown_time self._m_has_field_quit_settle_countdown_time = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_quit_settle_countdown_time', None) @property def has_field_event_interval(self): if hasattr(self, '_m_has_field_event_interval'): return self._m_has_field_event_interval self._m_has_field_event_interval = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_event_interval', None) @property def has_field_sub_type(self): if hasattr(self, '_m_has_field_sub_type'): return self._m_has_field_sub_type self._m_has_field_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_sub_type', None) @property def has_field_recommend_element_types(self): if hasattr(self, '_m_has_field_recommend_element_types'): return self._m_has_field_recommend_element_types self._m_has_field_recommend_element_types = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 8) != 0)) return getattr(self, '_m_has_field_recommend_element_types', None) @property def has_field_enter_cost_items(self): if hasattr(self, '_m_has_field_enter_cost_items'): return self._m_has_field_enter_cost_items self._m_has_field_enter_cost_items = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_enter_cost_items', None) @property def has_field_state_type(self): if hasattr(self, '_m_has_field_state_type'): return self._m_has_field_state_type self._m_has_field_state_type = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 8) != 0)) return getattr(self, '_m_has_field_state_type', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_first_pass_reward_preview_id(self): if hasattr(self, '_m_has_field_first_pass_reward_preview_id'): return self._m_has_field_first_pass_reward_preview_id self._m_has_field_first_pass_reward_preview_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_first_pass_reward_preview_id', None) @property def has_field_gear_desc(self): if hasattr(self, '_m_has_field_gear_desc'): return self._m_has_field_gear_desc self._m_has_field_gear_desc = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 128) != 0)) return getattr(self, '_m_has_field_gear_desc', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_level_config_map(self): if hasattr(self, '_m_has_field_level_config_map'): return self._m_has_field_level_config_map self._m_has_field_level_config_map = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 32) != 0)) return getattr(self, '_m_has_field_level_config_map', None) @property def has_field_involve_type(self): if hasattr(self, '_m_has_field_involve_type'): return self._m_has_field_involve_type self._m_has_field_involve_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_involve_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_forbidden_restart(self): if hasattr(self, '_m_has_field_forbidden_restart'): return self._m_has_field_forbidden_restart self._m_has_field_forbidden_restart = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_forbidden_restart', None) @property def has_field_display_name(self): if hasattr(self, '_m_has_field_display_name'): return self._m_has_field_display_name self._m_has_field_display_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_display_name', None) @property def has_field_day_enter_count(self): if hasattr(self, '_m_has_field_day_enter_count'): return self._m_has_field_day_enter_count self._m_has_field_day_enter_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_day_enter_count', None) @property def has_field_is_dynamic_level(self): if hasattr(self, '_m_has_field_is_dynamic_level'): return self._m_has_field_is_dynamic_level self._m_has_field_is_dynamic_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_dynamic_level', None) @property def has_field_revive_interval_time(self): if hasattr(self, '_m_has_field_revive_interval_time'): return self._m_has_field_revive_interval_time self._m_has_field_revive_interval_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_revive_interval_time', None) @property def has_field_revive_max_count(self): if hasattr(self, '_m_has_field_revive_max_count'): return self._m_has_field_revive_max_count self._m_has_field_revive_max_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_revive_max_count', None) @property def has_field_settle_countdown_time(self): if hasattr(self, '_m_has_field_settle_countdown_time'): return self._m_has_field_settle_countdown_time self._m_has_field_settle_countdown_time = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_settle_countdown_time', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_pass_reward_preview_id(self): if hasattr(self, '_m_has_field_pass_reward_preview_id'): return self._m_has_field_pass_reward_preview_id self._m_has_field_pass_reward_preview_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_pass_reward_preview_id', None) @property def has_field_serial_id(self): if hasattr(self, '_m_has_field_serial_id'): return self._m_has_field_serial_id self._m_has_field_serial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_serial_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_entry_pic_path(self): if hasattr(self, '_m_has_field_entry_pic_path'): return self._m_has_field_entry_pic_path self._m_has_field_entry_pic_path = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 4) != 0)) return getattr(self, '_m_has_field_entry_pic_path', None) @property def has_field_dont_show_push_tips(self): if hasattr(self, '_m_has_field_dont_show_push_tips'): return self._m_has_field_dont_show_push_tips self._m_has_field_dont_show_push_tips = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 2) != 0)) return getattr(self, '_m_has_field_dont_show_push_tips', None) @property def has_field_settle_ui_type(self): if hasattr(self, '_m_has_field_settle_ui_type'): return self._m_has_field_settle_ui_type self._m_has_field_settle_ui_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_settle_ui_type', None) @property def has_field_level_revise(self): if hasattr(self, '_m_has_field_level_revise'): return self._m_has_field_level_revise self._m_has_field_level_revise = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_level_revise', None) @property def has_field_recommend_tips(self): if hasattr(self, '_m_has_field_recommend_tips'): return self._m_has_field_recommend_tips self._m_has_field_recommend_tips = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 16) != 0)) return getattr(self, '_m_has_field_recommend_tips', None) @property def has_field_pass_jump_dungeon(self): if hasattr(self, '_m_has_field_pass_jump_dungeon'): return self._m_has_field_pass_jump_dungeon self._m_has_field_pass_jump_dungeon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_pass_jump_dungeon', None) @property def has_field_enable_quest_guide(self): if hasattr(self, '_m_has_field_enable_quest_guide'): return self._m_has_field_enable_quest_guide self._m_has_field_enable_quest_guide = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 64) != 0)) return getattr(self, '_m_has_field_enable_quest_guide', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_prev_dungeon_id(self): if hasattr(self, '_m_has_field_prev_dungeon_id'): return self._m_has_field_prev_dungeon_id self._m_has_field_prev_dungeon_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_prev_dungeon_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_fail_settle_countdown_time(self): if hasattr(self, '_m_has_field_fail_settle_countdown_time'): return self._m_has_field_fail_settle_countdown_time self._m_has_field_fail_settle_countdown_time = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_fail_settle_countdown_time', None) @property def has_field_show_level(self): if hasattr(self, '_m_has_field_show_level'): return self._m_has_field_show_level self._m_has_field_show_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_show_level', None) @property def has_field_limit_level(self): if hasattr(self, '_m_has_field_limit_level'): return self._m_has_field_limit_level self._m_has_field_limit_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_limit_level', None) @property def has_field_statue_cost_id(self): if hasattr(self, '_m_has_field_statue_cost_id'): return self._m_has_field_statue_cost_id self._m_has_field_statue_cost_id = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_statue_cost_id', None) @property def has_field_factor_icon(self): if hasattr(self, '_m_has_field_factor_icon'): return self._m_has_field_factor_icon self._m_has_field_factor_icon = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 32) != 0)) return getattr(self, '_m_has_field_factor_icon', None) @property def has_field_factor_pic(self): if hasattr(self, '_m_has_field_factor_pic'): return self._m_has_field_factor_pic self._m_has_field_factor_pic = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 16) != 0)) return getattr(self, '_m_has_field_factor_pic', None) class AddAvatarInCdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_increased_duration: self.increased_duration = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_increased_duration(self): if hasattr(self, '_m_has_field_increased_duration'): return self._m_has_field_increased_duration self._m_has_field_increased_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_increased_duration', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HuntingMonsterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_associated_monster_group_id: self.associated_monster_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hunting_finish_type: self.hunting_finish_type = Output.EnumHuntingMonsterFinishType(self._io, self, self._root) if self.has_field_affix: self.affix = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ability_group: self.ability_group = AuxTypes.String(self._io, self, self._root) if self.has_field_create_pos_type: self.create_pos_type = Output.EnumHuntingMonsterCreatePosType(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level_id: self.revise_level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_list: self.city_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumHuntingOfferDifficultyType(self._io, self, self._root) if self.has_field_limit_time: self.limit_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_point_num: self.search_point_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_cond: self.refresh_cond = Output.ArrayOfHuntingRefreshCondLengthS(self._io, self, self._root) if self.has_field_initial_pose: self.initial_pose = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_clue_text_id_list: self.clue_text_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_news_text: self.news_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trait_text: self.trait_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mechanism_title1: self.mechanism_title1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mechanism_desc1: self.mechanism_desc1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mechanism_title2: self.mechanism_title2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mechanism_desc2: self.mechanism_desc2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suite_id: self.suite_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_disable_wandering: self.is_disable_wandering = self._io.read_u1() if self.has_field_route_id: self.route_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_route_id(self): if hasattr(self, '_m_has_field_route_id'): return self._m_has_field_route_id self._m_has_field_route_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_route_id', None) @property def has_field_mechanism_title2(self): if hasattr(self, '_m_has_field_mechanism_title2'): return self._m_has_field_mechanism_title2 self._m_has_field_mechanism_title2 = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_mechanism_title2', None) @property def has_field_ability_group(self): if hasattr(self, '_m_has_field_ability_group'): return self._m_has_field_ability_group self._m_has_field_ability_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_ability_group', None) @property def has_field_mechanism_desc2(self): if hasattr(self, '_m_has_field_mechanism_desc2'): return self._m_has_field_mechanism_desc2 self._m_has_field_mechanism_desc2 = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_mechanism_desc2', None) @property def has_field_mechanism_title1(self): if hasattr(self, '_m_has_field_mechanism_title1'): return self._m_has_field_mechanism_title1 self._m_has_field_mechanism_title1 = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_mechanism_title1', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_revise_level_id(self): if hasattr(self, '_m_has_field_revise_level_id'): return self._m_has_field_revise_level_id self._m_has_field_revise_level_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_revise_level_id', None) @property def has_field_hunting_finish_type(self): if hasattr(self, '_m_has_field_hunting_finish_type'): return self._m_has_field_hunting_finish_type self._m_has_field_hunting_finish_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hunting_finish_type', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_mechanism_desc1(self): if hasattr(self, '_m_has_field_mechanism_desc1'): return self._m_has_field_mechanism_desc1 self._m_has_field_mechanism_desc1 = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_mechanism_desc1', None) @property def has_field_initial_pose(self): if hasattr(self, '_m_has_field_initial_pose'): return self._m_has_field_initial_pose self._m_has_field_initial_pose = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_initial_pose', None) @property def has_field_affix(self): if hasattr(self, '_m_has_field_affix'): return self._m_has_field_affix self._m_has_field_affix = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_affix', None) @property def has_field_refresh_cond(self): if hasattr(self, '_m_has_field_refresh_cond'): return self._m_has_field_refresh_cond self._m_has_field_refresh_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_refresh_cond', None) @property def has_field_search_point_num(self): if hasattr(self, '_m_has_field_search_point_num'): return self._m_has_field_search_point_num self._m_has_field_search_point_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_search_point_num', None) @property def has_field_limit_time(self): if hasattr(self, '_m_has_field_limit_time'): return self._m_has_field_limit_time self._m_has_field_limit_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_limit_time', None) @property def has_field_city_list(self): if hasattr(self, '_m_has_field_city_list'): return self._m_has_field_city_list self._m_has_field_city_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_city_list', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_trait_text(self): if hasattr(self, '_m_has_field_trait_text'): return self._m_has_field_trait_text self._m_has_field_trait_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_trait_text', None) @property def has_field_is_disable_wandering(self): if hasattr(self, '_m_has_field_is_disable_wandering'): return self._m_has_field_is_disable_wandering self._m_has_field_is_disable_wandering = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_is_disable_wandering', None) @property def has_field_clue_text_id_list(self): if hasattr(self, '_m_has_field_clue_text_id_list'): return self._m_has_field_clue_text_id_list self._m_has_field_clue_text_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_clue_text_id_list', None) @property def has_field_suite_id(self): if hasattr(self, '_m_has_field_suite_id'): return self._m_has_field_suite_id self._m_has_field_suite_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_suite_id', None) @property def has_field_news_text(self): if hasattr(self, '_m_has_field_news_text'): return self._m_has_field_news_text self._m_has_field_news_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_news_text', None) @property def has_field_associated_monster_group_id(self): if hasattr(self, '_m_has_field_associated_monster_group_id'): return self._m_has_field_associated_monster_group_id self._m_has_field_associated_monster_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_associated_monster_group_id', None) @property def has_field_create_pos_type(self): if hasattr(self, '_m_has_field_create_pos_type'): return self._m_has_field_create_pos_type self._m_has_field_create_pos_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_create_pos_type', None) class ConfigGadgetCreationLimit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tag: self.tag = AuxTypes.String(self._io, self, self._root) if self.has_field_gadget_i_ds: self.gadget_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tag', None) @property def has_field_gadget_i_ds(self): if hasattr(self, '_m_has_field_gadget_i_ds'): return self._m_has_field_gadget_i_ds self._m_has_field_gadget_i_ds = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadget_i_ds', None) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) class FurnitureSuiteExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_suite_id: self.suite_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_suite_name: self.suite_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suite_desc: self.suite_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drawing_id: self.drawing_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_favorite_npc_excel_id_vec: self.favorite_npc_excel_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_trans_str: self.trans_str = AuxTypes.String(self._io, self, self._root) if self.has_field_furn_type: self.furn_type = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_item_icon: self.item_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_map_icon: self.map_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_inter_ratio: self.inter_ratio = self._io.read_f4le() @property def has_field_drawing_id(self): if hasattr(self, '_m_has_field_drawing_id'): return self._m_has_field_drawing_id self._m_has_field_drawing_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_drawing_id', None) @property def has_field_furn_type(self): if hasattr(self, '_m_has_field_furn_type'): return self._m_has_field_furn_type self._m_has_field_furn_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_furn_type', None) @property def has_field_inter_ratio(self): if hasattr(self, '_m_has_field_inter_ratio'): return self._m_has_field_inter_ratio self._m_has_field_inter_ratio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_inter_ratio', None) @property def has_field_trans_str(self): if hasattr(self, '_m_has_field_trans_str'): return self._m_has_field_trans_str self._m_has_field_trans_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_trans_str', None) @property def has_field_item_icon(self): if hasattr(self, '_m_has_field_item_icon'): return self._m_has_field_item_icon self._m_has_field_item_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_item_icon', None) @property def has_field_map_icon(self): if hasattr(self, '_m_has_field_map_icon'): return self._m_has_field_map_icon self._m_has_field_map_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_map_icon', None) @property def has_field_suite_desc(self): if hasattr(self, '_m_has_field_suite_desc'): return self._m_has_field_suite_desc self._m_has_field_suite_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_suite_desc', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_suite_name(self): if hasattr(self, '_m_has_field_suite_name'): return self._m_has_field_suite_name self._m_has_field_suite_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_suite_name', None) @property def has_field_suite_id(self): if hasattr(self, '_m_has_field_suite_id'): return self._m_has_field_suite_id self._m_has_field_suite_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_suite_id', None) @property def has_field_favorite_npc_excel_id_vec(self): if hasattr(self, '_m_has_field_favorite_npc_excel_id_vec'): return self._m_has_field_favorite_npc_excel_id_vec self._m_has_field_favorite_npc_excel_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_favorite_npc_excel_id_vec', None) class ConfigCoopActionNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCoopBaseNode(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_list: self.action_list = Output.ArrayOfConfigCoopActionLengthU(self._io, self, self._root) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_list', None) @property def coop_node_id(self): if hasattr(self, '_m_coop_node_id'): return self._m_coop_node_id self._m_coop_node_id = self.base.coop_node_id return getattr(self, '_m_coop_node_id', None) @property def coop_node_type(self): if hasattr(self, '_m_coop_node_type'): return self._m_coop_node_type self._m_coop_node_type = self.base.coop_node_type return getattr(self, '_m_coop_node_type', None) @property def next_node_array(self): if hasattr(self, '_m_next_node_array'): return self._m_next_node_array self._m_next_node_array = self.base.next_node_array return getattr(self, '_m_next_node_array', None) class StateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumParticleShapeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ParticleShapeType, self.data.value) return getattr(self, '_m_value', None) class ConfigRigidbodyMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_const_speed_ratio: self.const_speed_ratio = self._io.read_f4le() if self.has_field_start_close_to_ground: self.start_close_to_ground = self._io.read_u1() if self.has_field_enable_close_to_ground_when_tick: self.enable_close_to_ground_when_tick = self._io.read_u1() if self.has_field_follow_reference_system: self.follow_reference_system = self._io.read_u1() if self.has_field_use_aniamtor_velocity: self.use_aniamtor_velocity = self._io.read_u1() if self.has_field_enable_sync_trans_to_server: self.enable_sync_trans_to_server = self._io.read_u1() if self.has_field_ignore_enable_rigidbody_dist: self.ignore_enable_rigidbody_dist = self._io.read_u1() @property def has_field_enable_close_to_ground_when_tick(self): if hasattr(self, '_m_has_field_enable_close_to_ground_when_tick'): return self._m_has_field_enable_close_to_ground_when_tick self._m_has_field_enable_close_to_ground_when_tick = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enable_close_to_ground_when_tick', None) @property def has_field_follow_reference_system(self): if hasattr(self, '_m_has_field_follow_reference_system'): return self._m_has_field_follow_reference_system self._m_has_field_follow_reference_system = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_follow_reference_system', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_ignore_enable_rigidbody_dist(self): if hasattr(self, '_m_has_field_ignore_enable_rigidbody_dist'): return self._m_has_field_ignore_enable_rigidbody_dist self._m_has_field_ignore_enable_rigidbody_dist = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_ignore_enable_rigidbody_dist', None) @property def has_field_enable_sync_trans_to_server(self): if hasattr(self, '_m_has_field_enable_sync_trans_to_server'): return self._m_has_field_enable_sync_trans_to_server self._m_has_field_enable_sync_trans_to_server = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_enable_sync_trans_to_server', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_use_aniamtor_velocity(self): if hasattr(self, '_m_has_field_use_aniamtor_velocity'): return self._m_has_field_use_aniamtor_velocity self._m_has_field_use_aniamtor_velocity = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_aniamtor_velocity', None) @property def has_field_start_close_to_ground(self): if hasattr(self, '_m_has_field_start_close_to_ground'): return self._m_has_field_start_close_to_ground self._m_has_field_start_close_to_ground = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_close_to_ground', None) @property def has_field_const_speed_ratio(self): if hasattr(self, '_m_has_field_const_speed_ratio'): return self._m_has_field_const_speed_ratio self._m_has_field_const_speed_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_const_speed_ratio', None) class ConfigFaceAnimation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GadgetInteractExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_interact_id: self.interact_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_type: self.action_type = Output.EnumInteractActionType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_list: self.action_list = Output.ArrayOfGadgetInteractActionConfigLengthS(self._io, self, self._root) if self.has_field_is_guest_interact: self.is_guest_interact = self._io.read_u1() if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_ui_title: self.ui_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ui_desc: self.ui_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_list: self.cond_list = Output.ArrayOfGadgetInteractCondLengthS(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_is_mp_mode_interact: self.is_mp_mode_interact = self._io.read_u1() @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_action_list', None) @property def has_field_ui_title(self): if hasattr(self, '_m_has_field_ui_title'): return self._m_has_field_ui_title self._m_has_field_ui_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_ui_title', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_action_type', None) @property def has_field_ui_desc(self): if hasattr(self, '_m_has_field_ui_desc'): return self._m_has_field_ui_desc self._m_has_field_ui_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_ui_desc', None) @property def has_field_is_guest_interact(self): if hasattr(self, '_m_has_field_is_guest_interact'): return self._m_has_field_is_guest_interact self._m_has_field_is_guest_interact = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_guest_interact', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param2', None) @property def has_field_is_mp_mode_interact(self): if hasattr(self, '_m_has_field_is_mp_mode_interact'): return self._m_has_field_is_mp_mode_interact self._m_has_field_is_mp_mode_interact = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_is_mp_mode_interact', None) @property def has_field_cond_list(self): if hasattr(self, '_m_has_field_cond_list'): return self._m_has_field_cond_list self._m_has_field_cond_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cond_list', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_interact_id(self): if hasattr(self, '_m_has_field_interact_id'): return self._m_has_field_interact_id self._m_has_field_interact_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_interact_id', None) class GearTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiMeleeChargeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiMeleeChargeData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiMeleeChargeData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigCostumeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effects: self.effects = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_gadgets: self.gadgets = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_audio: self.audio = Output.ConfigCostumeAudio(self._io, self, self._root) if self.has_field_weather_patterns: self.weather_patterns = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_event_patterns: self.event_patterns = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_gadgets(self): if hasattr(self, '_m_has_field_gadgets'): return self._m_has_field_gadgets self._m_has_field_gadgets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadgets', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_audio', None) @property def has_field_weather_patterns(self): if hasattr(self, '_m_has_field_weather_patterns'): return self._m_has_field_weather_patterns self._m_has_field_weather_patterns = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_weather_patterns', None) @property def has_field_event_patterns(self): if hasattr(self, '_m_has_field_event_patterns'): return self._m_has_field_event_patterns self._m_has_field_event_patterns = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_event_patterns', None) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effects', None) class KvpOfDictAuxTypesVlqBase128LeSArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) class ConfigAiPoseControlItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_time: self.min_time = self._io.read_f4le() if self.has_field_max_time: self.max_time = self._io.read_f4le() if self.has_field_pose_id: self.pose_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_random_pose: self.random_pose = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_switch_only_in_can_do_skill_state: self.switch_only_in_can_do_skill_state = self._io.read_u1() @property def has_field_min_time(self): if hasattr(self, '_m_has_field_min_time'): return self._m_has_field_min_time self._m_has_field_min_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_time', None) @property def has_field_random_pose(self): if hasattr(self, '_m_has_field_random_pose'): return self._m_has_field_random_pose self._m_has_field_random_pose = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_pose', None) @property def has_field_pose_id(self): if hasattr(self, '_m_has_field_pose_id'): return self._m_has_field_pose_id self._m_has_field_pose_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_pose_id', None) @property def has_field_max_time(self): if hasattr(self, '_m_has_field_max_time'): return self._m_has_field_max_time self._m_has_field_max_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_time', None) @property def has_field_switch_only_in_can_do_skill_state(self): if hasattr(self, '_m_has_field_switch_only_in_can_do_skill_state'): return self._m_has_field_switch_only_in_can_do_skill_state self._m_has_field_switch_only_in_can_do_skill_state = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_switch_only_in_can_do_skill_state', None) class QuestAcceptionMarkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_quest_id: self.sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_daily_npc: self.is_daily_npc = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fallback_position: self.fallback_position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_block_mp: self.block_mp = self._io.read_u1() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_acceptable_time_tips: self.acceptable_time_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_fallback_position(self): if hasattr(self, '_m_has_field_fallback_position'): return self._m_has_field_fallback_position self._m_has_field_fallback_position = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fallback_position', None) @property def has_field_block_mp(self): if hasattr(self, '_m_has_field_block_mp'): return self._m_has_field_block_mp self._m_has_field_block_mp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_block_mp', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_is_daily_npc(self): if hasattr(self, '_m_has_field_is_daily_npc'): return self._m_has_field_is_daily_npc self._m_has_field_is_daily_npc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_daily_npc', None) @property def has_field_sub_quest_id(self): if hasattr(self, '_m_has_field_sub_quest_id'): return self._m_has_field_sub_quest_id self._m_has_field_sub_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_quest_id', None) @property def has_field_acceptable_time_tips(self): if hasattr(self, '_m_has_field_acceptable_time_tips'): return self._m_has_field_acceptable_time_tips self._m_has_field_acceptable_time_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_acceptable_time_tips', None) class ConfigLocalGadgetCmd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cmd_exe_type: self.cmd_exe_type = Output.EnumLocalGadgetCmdExeType(self._io, self, self._root) @property def has_field_cmd_exe_type(self): if hasattr(self, '_m_has_field_cmd_exe_type'): return self._m_has_field_cmd_exe_type self._m_has_field_cmd_exe_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cmd_exe_type', None) class EntityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiBirdCirclingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiBirdCirclingData(self._io, self, self._root)) class DungeonChallengeConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfCombinedItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfCombinedItem(self._io, self, self._root)) class EnumBanGroupType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BanGroupType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigTornadoZoneLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigTornadoZone(self._io, self, self._root)) class CreateSeverGadgetOpTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_freshman_guide: self.is_freshman_guide = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) if self.has_field_on_check: self.on_check = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) if self.has_field_on_guide: self.on_guide = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) if self.has_field_finish_condition: self.finish_condition = Output.ArrayOfArrayOfDispConfigBaseGuideLengthULengthU(self._io, self, self._root) if self.has_field_on_finish: self.on_finish = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) if self.has_field_on_quit: self.on_quit = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) @property def has_field_on_check(self): if hasattr(self, '_m_has_field_on_check'): return self._m_has_field_on_check self._m_has_field_on_check = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_check', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_is_freshman_guide(self): if hasattr(self, '_m_has_field_is_freshman_guide'): return self._m_has_field_is_freshman_guide self._m_has_field_is_freshman_guide = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_freshman_guide', None) @property def has_field_on_quit(self): if hasattr(self, '_m_has_field_on_quit'): return self._m_has_field_on_quit self._m_has_field_on_quit = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_on_quit', None) @property def has_field_on_guide(self): if hasattr(self, '_m_has_field_on_guide'): return self._m_has_field_on_guide self._m_has_field_on_guide = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_guide', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_on_finish(self): if hasattr(self, '_m_has_field_on_finish'): return self._m_has_field_on_finish self._m_has_field_on_finish = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_on_finish', None) @property def has_field_finish_condition(self): if hasattr(self, '_m_has_field_finish_condition'): return self._m_has_field_finish_condition self._m_has_field_finish_condition = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_finish_condition', None) class ConfigQteStepButtonComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseComponent(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position_id: self.position_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_input_event: self.input_event = Output.EnumQteStepButtonInputType(self._io, self, self._root) if self.has_field_click_trigger: self.click_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) if self.has_field_style: self.style = Output.EnumQteStepButtonStyleType(self._io, self, self._root) if self.has_field_count_down_time: self.count_down_time = self._io.read_f4le() if self.has_field_count_down_change_trigger: self.count_down_change_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) if self.has_field_slide_dir_trigger: self.slide_dir_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) if self.has_field_slide_dir: self.slide_dir = Output.EnumQteStepButtonSlideDirectType(self._io, self, self._root) if self.has_field_slide_angle: self.slide_angle = self._io.read_f4le() if self.has_field_slide_touch_dis: self.slide_touch_dis = self._io.read_f4le() if self.has_field_slide_joypad_dis: self.slide_joypad_dis = self._io.read_f4le() @property def has_field_click_trigger(self): if hasattr(self, '_m_has_field_click_trigger'): return self._m_has_field_click_trigger self._m_has_field_click_trigger = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_click_trigger', None) @property def has_field_slide_angle(self): if hasattr(self, '_m_has_field_slide_angle'): return self._m_has_field_slide_angle self._m_has_field_slide_angle = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_slide_angle', None) @property def has_field_input_event(self): if hasattr(self, '_m_has_field_input_event'): return self._m_has_field_input_event self._m_has_field_input_event = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_input_event', None) @property def has_field_count_down_time(self): if hasattr(self, '_m_has_field_count_down_time'): return self._m_has_field_count_down_time self._m_has_field_count_down_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_count_down_time', None) @property def has_field_slide_dir_trigger(self): if hasattr(self, '_m_has_field_slide_dir_trigger'): return self._m_has_field_slide_dir_trigger self._m_has_field_slide_dir_trigger = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_slide_dir_trigger', None) @property def has_field_style(self): if hasattr(self, '_m_has_field_style'): return self._m_has_field_style self._m_has_field_style = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_style', None) @property def has_field_slide_joypad_dis(self): if hasattr(self, '_m_has_field_slide_joypad_dis'): return self._m_has_field_slide_joypad_dis self._m_has_field_slide_joypad_dis = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_slide_joypad_dis', None) @property def has_field_count_down_change_trigger(self): if hasattr(self, '_m_has_field_count_down_change_trigger'): return self._m_has_field_count_down_change_trigger self._m_has_field_count_down_change_trigger = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_count_down_change_trigger', None) @property def has_field_position_id(self): if hasattr(self, '_m_has_field_position_id'): return self._m_has_field_position_id self._m_has_field_position_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_position_id', None) @property def has_field_slide_dir(self): if hasattr(self, '_m_has_field_slide_dir'): return self._m_has_field_slide_dir self._m_has_field_slide_dir = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_slide_dir', None) @property def has_field_slide_touch_dis(self): if hasattr(self, '_m_has_field_slide_touch_dis'): return self._m_has_field_slide_touch_dis self._m_has_field_slide_touch_dis = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_slide_touch_dis', None) class JobTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideDelayFinishCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_delay_time: self.delay_time = self._io.read_f4le() @property def has_field_delay_time(self): if hasattr(self, '_m_has_field_delay_time'): return self._m_has_field_delay_time self._m_has_field_delay_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_delay_time', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class DispConfigHeadControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigHeadControl(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigMonsterHeadControl(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class WeatherTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_template_name: self.template_name = AuxTypes.String(self._io, self, self._root) if self.has_field_weather_type: self.weather_type = Output.EnumClimateType(self._io, self, self._root) if self.has_field_sunny_prob: self.sunny_prob = self._io.read_f4le() if self.has_field_cloudy_prob: self.cloudy_prob = self._io.read_f4le() if self.has_field_rain_prob: self.rain_prob = self._io.read_f4le() if self.has_field_thunderstorm_prob: self.thunderstorm_prob = self._io.read_f4le() if self.has_field_snow_prob: self.snow_prob = self._io.read_f4le() if self.has_field_mist_prob: self.mist_prob = self._io.read_f4le() @property def has_field_rain_prob(self): if hasattr(self, '_m_has_field_rain_prob'): return self._m_has_field_rain_prob self._m_has_field_rain_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_rain_prob', None) @property def has_field_snow_prob(self): if hasattr(self, '_m_has_field_snow_prob'): return self._m_has_field_snow_prob self._m_has_field_snow_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_snow_prob', None) @property def has_field_sunny_prob(self): if hasattr(self, '_m_has_field_sunny_prob'): return self._m_has_field_sunny_prob self._m_has_field_sunny_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sunny_prob', None) @property def has_field_cloudy_prob(self): if hasattr(self, '_m_has_field_cloudy_prob'): return self._m_has_field_cloudy_prob self._m_has_field_cloudy_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cloudy_prob', None) @property def has_field_thunderstorm_prob(self): if hasattr(self, '_m_has_field_thunderstorm_prob'): return self._m_has_field_thunderstorm_prob self._m_has_field_thunderstorm_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_thunderstorm_prob', None) @property def has_field_mist_prob(self): if hasattr(self, '_m_has_field_mist_prob'): return self._m_has_field_mist_prob self._m_has_field_mist_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mist_prob', None) @property def has_field_weather_type(self): if hasattr(self, '_m_has_field_weather_type'): return self._m_has_field_weather_type self._m_has_field_weather_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weather_type', None) @property def has_field_template_name(self): if hasattr(self, '_m_has_field_template_name'): return self._m_has_field_template_name self._m_has_field_template_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_template_name', None) class ConfigAiSkillSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_skill_elite_set: self.skill_elite_set = Output.DictOfU1ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_skill_elite_set(self): if hasattr(self, '_m_has_field_skill_elite_set'): return self._m_has_field_skill_elite_set self._m_has_field_skill_elite_set = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_elite_set', None) class ConfigInterContainer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lua_data_path: self.lua_data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_is_simple_talk: self.is_simple_talk = self._io.read_u1() if self.has_field_dont_use_default_finish: self.dont_use_default_finish = self._io.read_u1() if self.has_field_attack_mode_recover: self.attack_mode_recover = self._io.read_u1() if self.has_field_pause_actor: self.pause_actor = self._io.read_u1() if self.has_field_hide_pickable_entity: self.hide_pickable_entity = self._io.read_u1() if self.has_field_start_black_keep_time: self.start_black_keep_time = self._io.read_f4le() if self.has_field_entity_ban: self.entity_ban = AuxTypes.String(self._io, self, self._root) if self.has_field_is_key_interaction: self.is_key_interaction = self._io.read_u1() if self.has_field_disable_npc_lod: self.disable_npc_lod = self._io.read_u1() if self.has_field_is_auto_ban_npc: self.is_auto_ban_npc = self._io.read_u1() if self.has_field_is_ban_widget_pet: self.is_ban_widget_pet = self._io.read_u1() if self.has_field_ban_crowd_group_i_ds: self.ban_crowd_group_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_protect_npc_mobile_lod: self.protect_npc_mobile_lod = self._io.read_u1() if self.has_field_start_fade: self.start_fade = Output.ConfigInterFade(self._io, self, self._root) if self.has_field_end_fade: self.end_fade = Output.ConfigInterFade(self._io, self, self._root) if self.has_field_actors: self.actors = Output.ArrayOfConfigInterActorLengthU(self._io, self, self._root) if self.has_field_group: self.group = Output.ArrayOfArrayOfDispConfigBaseInterActionLengthULengthU(self._io, self, self._root) if self.has_field_group_id: self.group_id = Output.ArrayOfConfigInterGrpIdLengthU(self._io, self, self._root) if self.has_field_free_style_dic: self.free_style_dic = Output.DictOfAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_group(self): if hasattr(self, '_m_has_field_group'): return self._m_has_field_group self._m_has_field_group = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_group', None) @property def has_field_ban_crowd_group_i_ds(self): if hasattr(self, '_m_has_field_ban_crowd_group_i_ds'): return self._m_has_field_ban_crowd_group_i_ds self._m_has_field_ban_crowd_group_i_ds = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_ban_crowd_group_i_ds', None) @property def has_field_start_fade(self): if hasattr(self, '_m_has_field_start_fade'): return self._m_has_field_start_fade self._m_has_field_start_fade = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_start_fade', None) @property def has_field_free_style_dic(self): if hasattr(self, '_m_has_field_free_style_dic'): return self._m_has_field_free_style_dic self._m_has_field_free_style_dic = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_free_style_dic', None) @property def has_field_end_fade(self): if hasattr(self, '_m_has_field_end_fade'): return self._m_has_field_end_fade self._m_has_field_end_fade = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_end_fade', None) @property def has_field_is_simple_talk(self): if hasattr(self, '_m_has_field_is_simple_talk'): return self._m_has_field_is_simple_talk self._m_has_field_is_simple_talk = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_is_simple_talk', None) @property def has_field_lua_data_path(self): if hasattr(self, '_m_has_field_lua_data_path'): return self._m_has_field_lua_data_path self._m_has_field_lua_data_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_lua_data_path', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_dont_use_default_finish(self): if hasattr(self, '_m_has_field_dont_use_default_finish'): return self._m_has_field_dont_use_default_finish self._m_has_field_dont_use_default_finish = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_dont_use_default_finish', None) @property def has_field_protect_npc_mobile_lod(self): if hasattr(self, '_m_has_field_protect_npc_mobile_lod'): return self._m_has_field_protect_npc_mobile_lod self._m_has_field_protect_npc_mobile_lod = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_protect_npc_mobile_lod', None) @property def has_field_actors(self): if hasattr(self, '_m_has_field_actors'): return self._m_has_field_actors self._m_has_field_actors = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_actors', None) @property def has_field_is_key_interaction(self): if hasattr(self, '_m_has_field_is_key_interaction'): return self._m_has_field_is_key_interaction self._m_has_field_is_key_interaction = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_is_key_interaction', None) @property def has_field_disable_npc_lod(self): if hasattr(self, '_m_has_field_disable_npc_lod'): return self._m_has_field_disable_npc_lod self._m_has_field_disable_npc_lod = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_disable_npc_lod', None) @property def has_field_attack_mode_recover(self): if hasattr(self, '_m_has_field_attack_mode_recover'): return self._m_has_field_attack_mode_recover self._m_has_field_attack_mode_recover = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_attack_mode_recover', None) @property def has_field_pause_actor(self): if hasattr(self, '_m_has_field_pause_actor'): return self._m_has_field_pause_actor self._m_has_field_pause_actor = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_pause_actor', None) @property def has_field_is_auto_ban_npc(self): if hasattr(self, '_m_has_field_is_auto_ban_npc'): return self._m_has_field_is_auto_ban_npc self._m_has_field_is_auto_ban_npc = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_is_auto_ban_npc', None) @property def has_field_is_ban_widget_pet(self): if hasattr(self, '_m_has_field_is_ban_widget_pet'): return self._m_has_field_is_ban_widget_pet self._m_has_field_is_ban_widget_pet = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_is_ban_widget_pet', None) @property def has_field_start_black_keep_time(self): if hasattr(self, '_m_has_field_start_black_keep_time'): return self._m_has_field_start_black_keep_time self._m_has_field_start_black_keep_time = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_start_black_keep_time', None) @property def has_field_hide_pickable_entity(self): if hasattr(self, '_m_has_field_hide_pickable_entity'): return self._m_has_field_hide_pickable_entity self._m_has_field_hide_pickable_entity = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_hide_pickable_entity', None) @property def has_field_entity_ban(self): if hasattr(self, '_m_has_field_entity_ban'): return self._m_has_field_entity_ban self._m_has_field_entity_ban = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_entity_ban', None) class EnumButtonGuideType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ButtonGuideType, self.data.value) return getattr(self, '_m_value', None) class TriggerGadgetInteractive(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class CaptureTagsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_capture_tag_id: self.capture_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_codex_show_type: self.codex_show_type = Output.EnumCaptureCodexShowType(self._io, self, self._root) if self.has_field_item_limit_type: self.item_limit_type = Output.EnumItemLimitType(self._io, self, self._root) @property def has_field_capture_tag_id(self): if hasattr(self, '_m_has_field_capture_tag_id'): return self._m_has_field_capture_tag_id self._m_has_field_capture_tag_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_capture_tag_id', None) @property def has_field_codex_show_type(self): if hasattr(self, '_m_has_field_codex_show_type'): return self._m_has_field_codex_show_type self._m_has_field_codex_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_codex_show_type', None) @property def has_field_item_limit_type(self): if hasattr(self, '_m_has_field_item_limit_type'): return self._m_has_field_item_limit_type self._m_has_field_item_limit_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_limit_type', None) class EnumTalkExecType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkExecType, self.data.value) return getattr(self, '_m_value', None) class ConfigElementView(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_color_index: self.element_color_index = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeS(self._io, self, self._root) if self.has_field_terrain_grass_color: self.terrain_grass_color = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_element_color_index(self): if hasattr(self, '_m_has_field_element_color_index'): return self._m_has_field_element_color_index self._m_has_field_element_color_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_color_index', None) @property def has_field_terrain_grass_color(self): if hasattr(self, '_m_has_field_terrain_grass_color'): return self._m_has_field_terrain_grass_color self._m_has_field_terrain_grass_color = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_terrain_grass_color', None) class ActivityPotionLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_switch: self.block_switch = self._io.read_u1() if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_mark_id: self.dungeon_mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_mark_id: self.room_mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_wq_id_list: self.pre_wq_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hidden_wq_id_list: self.hidden_wq_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pre_quest_id_list: self.pre_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_change_entry_cond_id: self.change_entry_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_scene_id: self.room_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_world_scene_id: self.world_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_pre_quest_id_list(self): if hasattr(self, '_m_has_field_pre_quest_id_list'): return self._m_has_field_pre_quest_id_list self._m_has_field_pre_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pre_quest_id_list', None) @property def has_field_hidden_wq_id_list(self): if hasattr(self, '_m_has_field_hidden_wq_id_list'): return self._m_has_field_hidden_wq_id_list self._m_has_field_hidden_wq_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_hidden_wq_id_list', None) @property def has_field_dungeon_mark_id(self): if hasattr(self, '_m_has_field_dungeon_mark_id'): return self._m_has_field_dungeon_mark_id self._m_has_field_dungeon_mark_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_mark_id', None) @property def has_field_world_scene_id(self): if hasattr(self, '_m_has_field_world_scene_id'): return self._m_has_field_world_scene_id self._m_has_field_world_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_world_scene_id', None) @property def has_field_pre_wq_id_list(self): if hasattr(self, '_m_has_field_pre_wq_id_list'): return self._m_has_field_pre_wq_id_list self._m_has_field_pre_wq_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_wq_id_list', None) @property def has_field_room_mark_id(self): if hasattr(self, '_m_has_field_room_mark_id'): return self._m_has_field_room_mark_id self._m_has_field_room_mark_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_room_mark_id', None) @property def has_field_change_entry_cond_id(self): if hasattr(self, '_m_has_field_change_entry_cond_id'): return self._m_has_field_change_entry_cond_id self._m_has_field_change_entry_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_change_entry_cond_id', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_room_scene_id(self): if hasattr(self, '_m_has_field_room_scene_id'): return self._m_has_field_room_scene_id self._m_has_field_room_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_room_scene_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_block_switch(self): if hasattr(self, '_m_has_field_block_switch'): return self._m_has_field_block_switch self._m_has_field_block_switch = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_block_switch', None) class DailyTaskTagType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class EnumInteractionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InteractionType, self.data.value) return getattr(self, '_m_value', None) class DvalinS01pathEffsInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fly_state: self.fly_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_path_center: self.path_center = self._io.read_u1() if self.has_field_interval_max: self.interval_max = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_interval_min: self.interval_min = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_num_max: self.num_max = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_num_min: self.num_min = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_range_max: self.range_max = self._io.read_f4le() if self.has_field_range_min: self.range_min = self._io.read_f4le() if self.has_field_eular_max: self.eular_max = self._io.read_f4le() if self.has_field_eular_min: self.eular_min = self._io.read_f4le() if self.has_field_y_scale: self.y_scale = self._io.read_f4le() @property def has_field_range_min(self): if hasattr(self, '_m_has_field_range_min'): return self._m_has_field_range_min self._m_has_field_range_min = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_range_min', None) @property def has_field_eular_min(self): if hasattr(self, '_m_has_field_eular_min'): return self._m_has_field_eular_min self._m_has_field_eular_min = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_eular_min', None) @property def has_field_fly_state(self): if hasattr(self, '_m_has_field_fly_state'): return self._m_has_field_fly_state self._m_has_field_fly_state = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_fly_state', None) @property def has_field_interval_min(self): if hasattr(self, '_m_has_field_interval_min'): return self._m_has_field_interval_min self._m_has_field_interval_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_interval_min', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_effect_name', None) @property def has_field_eular_max(self): if hasattr(self, '_m_has_field_eular_max'): return self._m_has_field_eular_max self._m_has_field_eular_max = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_eular_max', None) @property def has_field_range_max(self): if hasattr(self, '_m_has_field_range_max'): return self._m_has_field_range_max self._m_has_field_range_max = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_range_max', None) @property def has_field_path_center(self): if hasattr(self, '_m_has_field_path_center'): return self._m_has_field_path_center self._m_has_field_path_center = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_path_center', None) @property def has_field_num_min(self): if hasattr(self, '_m_has_field_num_min'): return self._m_has_field_num_min self._m_has_field_num_min = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_num_min', None) @property def has_field_interval_max(self): if hasattr(self, '_m_has_field_interval_max'): return self._m_has_field_interval_max self._m_has_field_interval_max = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_interval_max', None) @property def has_field_y_scale(self): if hasattr(self, '_m_has_field_y_scale'): return self._m_has_field_y_scale self._m_has_field_y_scale = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_y_scale', None) @property def has_field_num_max(self): if hasattr(self, '_m_has_field_num_max'): return self._m_has_field_num_max self._m_has_field_num_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_num_max', None) class DictOfEnumOptionTypeConfigComprehensiveQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumOptionTypeConfigComprehensiveQualitySetting(self._io, self, self._root)) class ForgeRandomExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExcelMailType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExcelMailType, self.data.value) return getattr(self, '_m_value', None) class AvatarSkillDepotExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigGadgetStateAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigGadgetStateAction(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigGadgetStateFireAiSound(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigGadgetStateEnableAction(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigGadgetStateSendEffectTrigger(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetStateFireEffect(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigGadgetStateSetAnimInt(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigGadgetStateEnableGadgetIntee(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigGadgetStateDisableRadarHint(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigGadgetStateSetAnimTrigger(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigErosionArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMist(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_back: self.is_back = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def sort_id(self): if hasattr(self, '_m_sort_id'): return self._m_sort_id self._m_sort_id = self.base.sort_id return getattr(self, '_m_sort_id', None) @property def need_anim(self): if hasattr(self, '_m_need_anim'): return self._m_need_anim self._m_need_anim = self.base.need_anim return getattr(self, '_m_need_anim', None) @property def has_field_is_back(self): if hasattr(self, '_m_has_field_is_back'): return self._m_has_field_is_back self._m_has_field_is_back = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_back', None) @property def map_pos_list(self): if hasattr(self, '_m_map_pos_list'): return self._m_map_pos_list self._m_map_pos_list = self.base.map_pos_list return getattr(self, '_m_map_pos_list', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) @property def show_unlock_scene_point(self): if hasattr(self, '_m_show_unlock_scene_point'): return self._m_show_unlock_scene_point self._m_show_unlock_scene_point = self.base.show_unlock_scene_point return getattr(self, '_m_show_unlock_scene_point', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_index', None) @property def prefab_path(self): if hasattr(self, '_m_prefab_path'): return self._m_prefab_path self._m_prefab_path = self.base.prefab_path return getattr(self, '_m_prefab_path', None) @property def hide_scene_point_list(self): if hasattr(self, '_m_hide_scene_point_list'): return self._m_hide_scene_point_list self._m_hide_scene_point_list = self.base.hide_scene_point_list return getattr(self, '_m_hide_scene_point_list', None) class DictOfAuxTypesStringConfigPerfBoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfBoolItem(self._io, self, self._root)) class KvpOfDictAuxTypesStringConfigPerfBoolItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfBoolItemOverrideInfo(self._io, self, self._root) class EnumWidgetBusinessType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetBusinessType, self.data.value) return getattr(self, '_m_value', None) class DummyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_list: self.action_list = Output.ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(self._io, self, self._root) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumGuideButtonClick(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideButtonClick, self.data.value) return getattr(self, '_m_value', None) class CoopCgTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigHomeworldBlockAutoGenLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldBlockAutoGen(self._io, self, self._root)) class ArrayOfEnumElementReactionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumElementReactionType(self._io, self, self._root)) class DamageByAttackValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attacker: self.attacker = Output.EnumDamageAttacker(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_attack_info: self.attack_info = Output.ConfigAttackInfo(self._io, self, self._root) @property def has_field_attack_info(self): if hasattr(self, '_m_has_field_attack_info'): return self._m_has_field_attack_info self._m_has_field_attack_info = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attack_info', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_attacker(self): if hasattr(self, '_m_has_field_attacker'): return self._m_has_field_attacker self._m_has_field_attacker = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attacker', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class EchoShellSummerTimeDungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicStringCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.String(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class MpCrucibleRewardConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview', None) class ArrayOfEnumQuestStateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumQuestState(self._io, self, self._root)) class ConfigPlayEffectAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_index: self.effect_index = AuxTypes.String(self._io, self, self._root) if self.has_field_pattern_name: self.pattern_name = AuxTypes.String(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_euler: self.euler = Output.Vector(self._io, self, self._root) if self.has_field_scale: self.scale = Output.Vector(self._io, self, self._root) if self.has_field_is_loop: self.is_loop = self._io.read_u1() if self.has_field_attach_to_entity: self.attach_to_entity = self._io.read_u1() if self.has_field_is_remove: self.is_remove = self._io.read_u1() if self.has_field_attach_gadget_id: self.attach_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attach_gadget_sub_key: self.attach_gadget_sub_key = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_attach_gadget_sub_key(self): if hasattr(self, '_m_has_field_attach_gadget_sub_key'): return self._m_has_field_attach_gadget_sub_key self._m_has_field_attach_gadget_sub_key = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_attach_gadget_sub_key', None) @property def has_field_attach_gadget_id(self): if hasattr(self, '_m_has_field_attach_gadget_id'): return self._m_has_field_attach_gadget_id self._m_has_field_attach_gadget_id = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_attach_gadget_id', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_euler(self): if hasattr(self, '_m_has_field_euler'): return self._m_has_field_euler self._m_has_field_euler = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_euler', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_is_loop(self): if hasattr(self, '_m_has_field_is_loop'): return self._m_has_field_is_loop self._m_has_field_is_loop = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_is_loop', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_is_remove(self): if hasattr(self, '_m_has_field_is_remove'): return self._m_has_field_is_remove self._m_has_field_is_remove = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_is_remove', None) @property def has_field_attach_to_entity(self): if hasattr(self, '_m_has_field_attach_to_entity'): return self._m_has_field_attach_to_entity self._m_has_field_attach_to_entity = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_attach_to_entity', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_pattern_name(self): if hasattr(self, '_m_has_field_pattern_name'): return self._m_has_field_pattern_name self._m_has_field_pattern_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_pattern_name', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_effect_index', None) class ContextEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetToyTakePhoto(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_has_camera_effect: self.has_camera_effect = self._io.read_u1() if self.has_field_camera_ui_effect: self.camera_ui_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_camera_screen_effect: self.camera_screen_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_main_camera_effect: self.main_camera_effect = AuxTypes.String(self._io, self, self._root) @property def has_field_camera_ui_effect(self): if hasattr(self, '_m_has_field_camera_ui_effect'): return self._m_has_field_camera_ui_effect self._m_has_field_camera_ui_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camera_ui_effect', None) @property def has_field_camera_screen_effect(self): if hasattr(self, '_m_has_field_camera_screen_effect'): return self._m_has_field_camera_screen_effect self._m_has_field_camera_screen_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camera_screen_effect', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_main_camera_effect(self): if hasattr(self, '_m_has_field_main_camera_effect'): return self._m_has_field_main_camera_effect self._m_has_field_main_camera_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_main_camera_effect', None) @property def has_field_has_camera_effect(self): if hasattr(self, '_m_has_field_has_camera_effect'): return self._m_has_field_has_camera_effect self._m_has_field_has_camera_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_has_camera_effect', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class DispConfigPerfItemBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigPerfItemBase(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigPerfGradeItem(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigPerfCombinedItem(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigPerfNumberItem(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigPerfStringKeyItem(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigPerfBoolItem(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigPerfNumberArrayItem(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigSpatialBoxRoomTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_size', None) class EnumShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShowType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiNeuronHitBuddySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_feel_range: self.feel_range = self._io.read_f4le() if self.has_field_responser_concern_type: self.responser_concern_type = Output.EnumConcernType(self._io, self, self._root) if self.has_field_responser_camp_type: self.responser_camp_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_trigger_responser_concern_type: self.trigger_responser_concern_type = Output.EnumConcernType(self._io, self, self._root) if self.has_field_trigger_responser_camp_type: self.trigger_responser_camp_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_reserve_time: self.reserve_time = self._io.read_f4le() @property def has_field_trigger_responser_concern_type(self): if hasattr(self, '_m_has_field_trigger_responser_concern_type'): return self._m_has_field_trigger_responser_concern_type self._m_has_field_trigger_responser_concern_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_trigger_responser_concern_type', None) @property def has_field_reserve_time(self): if hasattr(self, '_m_has_field_reserve_time'): return self._m_has_field_reserve_time self._m_has_field_reserve_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_reserve_time', None) @property def has_field_feel_range(self): if hasattr(self, '_m_has_field_feel_range'): return self._m_has_field_feel_range self._m_has_field_feel_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_feel_range', None) @property def has_field_responser_camp_type(self): if hasattr(self, '_m_has_field_responser_camp_type'): return self._m_has_field_responser_camp_type self._m_has_field_responser_camp_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_responser_camp_type', None) @property def has_field_trigger_responser_camp_type(self): if hasattr(self, '_m_has_field_trigger_responser_camp_type'): return self._m_has_field_trigger_responser_camp_type self._m_has_field_trigger_responser_camp_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_trigger_responser_camp_type', None) @property def has_field_responser_concern_type(self): if hasattr(self, '_m_has_field_responser_concern_type'): return self._m_has_field_responser_concern_type self._m_has_field_responser_concern_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_responser_concern_type', None) class ConfigAvatarControllerAssembly(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_controller_path: self.controller_path = AuxTypes.String(self._io, self, self._root) if self.has_field_normal_move_subs: self.normal_move_subs = AuxTypes.String(self._io, self, self._root) if self.has_field_weapon_move_subs: self.weapon_move_subs = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_subs: self.skill_subs = Output.ConfigAvatarControllerAssemblySkillSubs(self._io, self, self._root) @property def has_field_controller_path(self): if hasattr(self, '_m_has_field_controller_path'): return self._m_has_field_controller_path self._m_has_field_controller_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_controller_path', None) @property def has_field_normal_move_subs(self): if hasattr(self, '_m_has_field_normal_move_subs'): return self._m_has_field_normal_move_subs self._m_has_field_normal_move_subs = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_normal_move_subs', None) @property def has_field_weapon_move_subs(self): if hasattr(self, '_m_has_field_weapon_move_subs'): return self._m_has_field_weapon_move_subs self._m_has_field_weapon_move_subs = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_weapon_move_subs', None) @property def has_field_skill_subs(self): if hasattr(self, '_m_has_field_skill_subs'): return self._m_has_field_skill_subs self._m_has_field_skill_subs = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_skill_subs', None) class EnumChargeFillEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChargeFillEffect, self.data.value) return getattr(self, '_m_value', None) class AudioMutualExclusion(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_event_name_a: self.event_name_a = AuxTypes.String(self._io, self, self._root) if self.has_field_event_name_b: self.event_name_b = AuxTypes.String(self._io, self, self._root) if self.has_field_scope: self.scope = Output.EnumAudioScope(self._io, self, self._root) @property def has_field_event_name_a(self): if hasattr(self, '_m_has_field_event_name_a'): return self._m_has_field_event_name_a self._m_has_field_event_name_a = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_event_name_a', None) @property def has_field_event_name_b(self): if hasattr(self, '_m_has_field_event_name_b'): return self._m_has_field_event_name_b self._m_has_field_event_name_b = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_name_b', None) @property def has_field_scope(self): if hasattr(self, '_m_has_field_scope'): return self._m_has_field_scope self._m_has_field_scope = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scope', None) class EnumTimerLimitType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TimerLimitType, self.data.value) return getattr(self, '_m_value', None) class EnumWeaponEnhanceRuleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WeaponEnhanceRuleType, self.data.value) return getattr(self, '_m_value', None) class SelectTargetsByEquipParts(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_equip_part_names: self.equip_part_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_equip_part_names(self): if hasattr(self, '_m_has_field_equip_part_names'): return self._m_has_field_equip_part_names self._m_has_field_equip_part_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip_part_names', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class EnumKeyboardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.KeyboardType, self.data.value) return getattr(self, '_m_value', None) class ConfigInputCheck(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_input_event_check_white_list: self.config_input_event_check_white_list = Output.ConfigInputEventCheckWhiteList(self._io, self, self._root) @property def has_field_config_input_event_check_white_list(self): if hasattr(self, '_m_has_field_config_input_event_check_white_list'): return self._m_has_field_config_input_event_check_white_list self._m_has_field_config_input_event_check_white_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_input_event_check_white_list', None) class FleurFairDungeonStatMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TrialAvatarTemplatePlaceholderTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideInfoDialogAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.String(self._io, self, self._root) if self.has_field_on_ok_actions: self.on_ok_actions = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) if self.has_field_on_cancel_actions: self.on_cancel_actions = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_content', None) @property def has_field_on_ok_actions(self): if hasattr(self, '_m_has_field_on_ok_actions'): return self._m_has_field_on_ok_actions self._m_has_field_on_ok_actions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_ok_actions', None) @property def has_field_on_cancel_actions(self): if hasattr(self, '_m_has_field_on_cancel_actions'): return self._m_has_field_on_cancel_actions self._m_has_field_on_cancel_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_cancel_actions', None) class KvpOfDictEnumEFootprintPlatformConfigFootprintEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumEFootprintPlatform(self._io, self, self._root) self.value = Output.ConfigFootprintEffect(self._io, self, self._root) class MechanicusSequenceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sequence_id: self.sequence_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mechanicus_id: self.mechanicus_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_level: self.open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_gear_list: self.open_gear_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gear_level_limite: self.gear_level_limite = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_money_limite: self.gear_money_limite = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_map_list: self.open_map_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_open_map_list(self): if hasattr(self, '_m_has_field_open_map_list'): return self._m_has_field_open_map_list self._m_has_field_open_map_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_open_map_list', None) @property def has_field_gear_money_limite(self): if hasattr(self, '_m_has_field_gear_money_limite'): return self._m_has_field_gear_money_limite self._m_has_field_gear_money_limite = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_gear_money_limite', None) @property def has_field_mechanicus_id(self): if hasattr(self, '_m_has_field_mechanicus_id'): return self._m_has_field_mechanicus_id self._m_has_field_mechanicus_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mechanicus_id', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_open_level(self): if hasattr(self, '_m_has_field_open_level'): return self._m_has_field_open_level self._m_has_field_open_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_level', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_open_gear_list(self): if hasattr(self, '_m_has_field_open_gear_list'): return self._m_has_field_open_gear_list self._m_has_field_open_gear_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_gear_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_sequence_id(self): if hasattr(self, '_m_has_field_sequence_id'): return self._m_has_field_sequence_id self._m_has_field_sequence_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sequence_id', None) @property def has_field_gear_level_limite(self): if hasattr(self, '_m_has_field_gear_level_limite'): return self._m_has_field_gear_level_limite self._m_has_field_gear_level_limite = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gear_level_limite', None) class FindHilichurlAssignmentExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_type: self.activity_type = Output.EnumNewActivityType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_scene_tag: self.activity_scene_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_is_load_terrain: self.is_load_terrain = self._io.read_u1() if self.has_field_cond_group_id: self.cond_group_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_ban_client_ui: self.is_ban_client_ui = self._io.read_u1() @property def has_field_activity_type(self): if hasattr(self, '_m_has_field_activity_type'): return self._m_has_field_activity_type self._m_has_field_activity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_type', None) @property def has_field_is_ban_client_ui(self): if hasattr(self, '_m_has_field_is_ban_client_ui'): return self._m_has_field_is_ban_client_ui self._m_has_field_is_ban_client_ui = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_ban_client_ui', None) @property def has_field_is_load_terrain(self): if hasattr(self, '_m_has_field_is_load_terrain'): return self._m_has_field_is_load_terrain self._m_has_field_is_load_terrain = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_load_terrain', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_activity_scene_tag(self): if hasattr(self, '_m_has_field_activity_scene_tag'): return self._m_has_field_activity_scene_tag self._m_has_field_activity_scene_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_activity_scene_tag', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_cond_group_id(self): if hasattr(self, '_m_has_field_cond_group_id'): return self._m_has_field_cond_group_id self._m_has_field_cond_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cond_group_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigAiFollowServerRouteSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFollowServerRouteData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFollowServerRouteData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class TextShowPlaceComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBornBySelectedPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class CustomGadgetSlotLevelTagConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByVehicleIsCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfConfigAbilityNodeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAbilityNode(self._io, self, self._root)) class ByEntityTypes(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_reject: self.reject = self._io.read_u1() if self.has_field_use_event_source: self.use_event_source = self._io.read_u1() if self.has_field_is_authority: self.is_authority = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_reject(self): if hasattr(self, '_m_has_field_reject'): return self._m_has_field_reject self._m_has_field_reject = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reject', None) @property def has_field_use_event_source(self): if hasattr(self, '_m_has_field_use_event_source'): return self._m_has_field_use_event_source self._m_has_field_use_event_source = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_event_source', None) @property def has_field_is_authority(self): if hasattr(self, '_m_has_field_is_authority'): return self._m_has_field_is_authority self._m_has_field_is_authority = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_authority', None) @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_types', None) class ArrayOfConfigMusicCameraLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMusicCamera(self._io, self, self._root)) class ConfigAudioCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_impact_event: self.impact_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_arrow_impact_head_event: self.arrow_impact_head_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_bush_impact_event: self.bush_impact_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_tree_impact_event: self.tree_impact_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_put_away_weapon_event: self.put_away_weapon_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_strike_type_switch_key: self.strike_type_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_strike_type_switch_map: self.strike_type_switch_map = Output.DictOfEnumStrikeTypeConfigWwiseString(self._io, self, self._root) if self.has_field_strike_type_switch_default: self.strike_type_switch_default = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_element_type_switch_key: self.element_type_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_element_type_switch_map: self.element_type_switch_map = Output.DictOfEnumElementTypeConfigWwiseString(self._io, self, self._root) if self.has_field_element_type_switch_default: self.element_type_switch_default = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_hit_scene_event: self.hit_scene_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_whether_recurring_switch_key: self.whether_recurring_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_hit_oneshot_switch_value: self.hit_oneshot_switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_hit_recurring_switch_value: self.hit_recurring_switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_entity_fade_out_event: self.entity_fade_out_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_patroller_temperature_rtpc: self.patroller_temperature_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_patroller_aware_event: self.patroller_aware_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_patroller_alert_event: self.patroller_alert_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_patroller_calm_event: self.patroller_calm_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_impact_override_events: self.impact_override_events = Output.ArrayOfAudioImpactOverrideEventLengthU(self._io, self, self._root) if self.has_field_arrow_impact_override_events: self.arrow_impact_override_events = Output.ArrayOfAudioImpactOverrideEventLengthU(self._io, self, self._root) if self.has_field_hitting_scene_ignore_list: self.hitting_scene_ignore_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_most_dangerous_rtpc_key: self.is_most_dangerous_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_is_ending_hit_rtpc_key: self.is_ending_hit_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_cirt_damage_rate_rtpc_key: self.cirt_damage_rate_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_put_away_weapon_event(self): if hasattr(self, '_m_has_field_put_away_weapon_event'): return self._m_has_field_put_away_weapon_event self._m_has_field_put_away_weapon_event = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_put_away_weapon_event', None) @property def has_field_element_type_switch_key(self): if hasattr(self, '_m_has_field_element_type_switch_key'): return self._m_has_field_element_type_switch_key self._m_has_field_element_type_switch_key = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_element_type_switch_key', None) @property def has_field_impact_event(self): if hasattr(self, '_m_has_field_impact_event'): return self._m_has_field_impact_event self._m_has_field_impact_event = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_impact_event', None) @property def has_field_hit_scene_event(self): if hasattr(self, '_m_has_field_hit_scene_event'): return self._m_has_field_hit_scene_event self._m_has_field_hit_scene_event = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_hit_scene_event', None) @property def has_field_patroller_alert_event(self): if hasattr(self, '_m_has_field_patroller_alert_event'): return self._m_has_field_patroller_alert_event self._m_has_field_patroller_alert_event = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_patroller_alert_event', None) @property def has_field_hit_oneshot_switch_value(self): if hasattr(self, '_m_has_field_hit_oneshot_switch_value'): return self._m_has_field_hit_oneshot_switch_value self._m_has_field_hit_oneshot_switch_value = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_hit_oneshot_switch_value', None) @property def has_field_patroller_temperature_rtpc(self): if hasattr(self, '_m_has_field_patroller_temperature_rtpc'): return self._m_has_field_patroller_temperature_rtpc self._m_has_field_patroller_temperature_rtpc = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_patroller_temperature_rtpc', None) @property def has_field_patroller_calm_event(self): if hasattr(self, '_m_has_field_patroller_calm_event'): return self._m_has_field_patroller_calm_event self._m_has_field_patroller_calm_event = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_patroller_calm_event', None) @property def has_field_element_type_switch_map(self): if hasattr(self, '_m_has_field_element_type_switch_map'): return self._m_has_field_element_type_switch_map self._m_has_field_element_type_switch_map = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_element_type_switch_map', None) @property def has_field_impact_override_events(self): if hasattr(self, '_m_has_field_impact_override_events'): return self._m_has_field_impact_override_events self._m_has_field_impact_override_events = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_impact_override_events', None) @property def has_field_whether_recurring_switch_key(self): if hasattr(self, '_m_has_field_whether_recurring_switch_key'): return self._m_has_field_whether_recurring_switch_key self._m_has_field_whether_recurring_switch_key = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_whether_recurring_switch_key', None) @property def has_field_hitting_scene_ignore_list(self): if hasattr(self, '_m_has_field_hitting_scene_ignore_list'): return self._m_has_field_hitting_scene_ignore_list self._m_has_field_hitting_scene_ignore_list = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_hitting_scene_ignore_list', None) @property def has_field_entity_fade_out_event(self): if hasattr(self, '_m_has_field_entity_fade_out_event'): return self._m_has_field_entity_fade_out_event self._m_has_field_entity_fade_out_event = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_entity_fade_out_event', None) @property def has_field_tree_impact_event(self): if hasattr(self, '_m_has_field_tree_impact_event'): return self._m_has_field_tree_impact_event self._m_has_field_tree_impact_event = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_tree_impact_event', None) @property def has_field_cirt_damage_rate_rtpc_key(self): if hasattr(self, '_m_has_field_cirt_damage_rate_rtpc_key'): return self._m_has_field_cirt_damage_rate_rtpc_key self._m_has_field_cirt_damage_rate_rtpc_key = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_cirt_damage_rate_rtpc_key', None) @property def has_field_bush_impact_event(self): if hasattr(self, '_m_has_field_bush_impact_event'): return self._m_has_field_bush_impact_event self._m_has_field_bush_impact_event = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_bush_impact_event', None) @property def has_field_patroller_aware_event(self): if hasattr(self, '_m_has_field_patroller_aware_event'): return self._m_has_field_patroller_aware_event self._m_has_field_patroller_aware_event = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_patroller_aware_event', None) @property def has_field_strike_type_switch_map(self): if hasattr(self, '_m_has_field_strike_type_switch_map'): return self._m_has_field_strike_type_switch_map self._m_has_field_strike_type_switch_map = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_strike_type_switch_map', None) @property def has_field_arrow_impact_head_event(self): if hasattr(self, '_m_has_field_arrow_impact_head_event'): return self._m_has_field_arrow_impact_head_event self._m_has_field_arrow_impact_head_event = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_arrow_impact_head_event', None) @property def has_field_is_ending_hit_rtpc_key(self): if hasattr(self, '_m_has_field_is_ending_hit_rtpc_key'): return self._m_has_field_is_ending_hit_rtpc_key self._m_has_field_is_ending_hit_rtpc_key = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_is_ending_hit_rtpc_key', None) @property def has_field_is_most_dangerous_rtpc_key(self): if hasattr(self, '_m_has_field_is_most_dangerous_rtpc_key'): return self._m_has_field_is_most_dangerous_rtpc_key self._m_has_field_is_most_dangerous_rtpc_key = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_is_most_dangerous_rtpc_key', None) @property def has_field_hit_recurring_switch_value(self): if hasattr(self, '_m_has_field_hit_recurring_switch_value'): return self._m_has_field_hit_recurring_switch_value self._m_has_field_hit_recurring_switch_value = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_hit_recurring_switch_value', None) @property def has_field_strike_type_switch_default(self): if hasattr(self, '_m_has_field_strike_type_switch_default'): return self._m_has_field_strike_type_switch_default self._m_has_field_strike_type_switch_default = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_strike_type_switch_default', None) @property def has_field_arrow_impact_override_events(self): if hasattr(self, '_m_has_field_arrow_impact_override_events'): return self._m_has_field_arrow_impact_override_events self._m_has_field_arrow_impact_override_events = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_arrow_impact_override_events', None) @property def has_field_element_type_switch_default(self): if hasattr(self, '_m_has_field_element_type_switch_default'): return self._m_has_field_element_type_switch_default self._m_has_field_element_type_switch_default = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_element_type_switch_default', None) @property def has_field_strike_type_switch_key(self): if hasattr(self, '_m_has_field_strike_type_switch_key'): return self._m_has_field_strike_type_switch_key self._m_has_field_strike_type_switch_key = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_strike_type_switch_key', None) class ConfigLevelPolygon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_local_polygon_id: self.local_polygon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_y_max: self.y_max = self._io.read_f4le() if self.has_field_y_min: self.y_min = self._io.read_f4le() if self.has_field_vertices: self.vertices = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_tags: self.tags = Output.ArrayOfEnumConfigLevelPolygonTagLengthU(self._io, self, self._root) @property def has_field_y_max(self): if hasattr(self, '_m_has_field_y_max'): return self._m_has_field_y_max self._m_has_field_y_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y_max', None) @property def has_field_y_min(self): if hasattr(self, '_m_has_field_y_min'): return self._m_has_field_y_min self._m_has_field_y_min = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_y_min', None) @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_tags', None) @property def has_field_vertices(self): if hasattr(self, '_m_has_field_vertices'): return self._m_has_field_vertices self._m_has_field_vertices = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_vertices', None) @property def has_field_local_polygon_id(self): if hasattr(self, '_m_has_field_local_polygon_id'): return self._m_has_field_local_polygon_id self._m_has_field_local_polygon_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_local_polygon_id', None) class Uint32NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ConfigMainCoopGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_interaction_map: self.coop_interaction_map = Output.DictOfAuxTypesVlqBase128LeUConfigCoopInteractionGroup(self._io, self, self._root) if self.has_field_sub_start_point_map: self.sub_start_point_map = Output.DictOfAuxTypesVlqBase128LeUCoopSubStartPoint(self._io, self, self._root) if self.has_field_save_point_map: self.save_point_map = Output.DictOfAuxTypesVlqBase128LeUCoopSavePoint(self._io, self, self._root) if self.has_field_confidence_value: self.confidence_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_confidence_value: self.max_confidence_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_temperament_map: self.temperament_map = Output.DictOfEnumCoopTemperamentTypeCoopTemperament(self._io, self, self._root) if self.has_field_use_confidence: self.use_confidence = self._io.read_u1() if self.has_field_use_temperament: self.use_temperament = self._io.read_u1() if self.has_field_coop_temp_value_map: self.coop_temp_value_map = Output.DictOfAuxTypesVlqBase128LeUCoopTempValue(self._io, self, self._root) @property def has_field_coop_interaction_map(self): if hasattr(self, '_m_has_field_coop_interaction_map'): return self._m_has_field_coop_interaction_map self._m_has_field_coop_interaction_map = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_coop_interaction_map', None) @property def has_field_sub_start_point_map(self): if hasattr(self, '_m_has_field_sub_start_point_map'): return self._m_has_field_sub_start_point_map self._m_has_field_sub_start_point_map = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_sub_start_point_map', None) @property def has_field_use_temperament(self): if hasattr(self, '_m_has_field_use_temperament'): return self._m_has_field_use_temperament self._m_has_field_use_temperament = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_use_temperament', None) @property def has_field_coop_temp_value_map(self): if hasattr(self, '_m_has_field_coop_temp_value_map'): return self._m_has_field_coop_temp_value_map self._m_has_field_coop_temp_value_map = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_coop_temp_value_map', None) @property def has_field_confidence_value(self): if hasattr(self, '_m_has_field_confidence_value'): return self._m_has_field_confidence_value self._m_has_field_confidence_value = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_confidence_value', None) @property def has_field_use_confidence(self): if hasattr(self, '_m_has_field_use_confidence'): return self._m_has_field_use_confidence self._m_has_field_use_confidence = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_use_confidence', None) @property def has_field_save_point_map(self): if hasattr(self, '_m_has_field_save_point_map'): return self._m_has_field_save_point_map self._m_has_field_save_point_map = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_save_point_map', None) @property def has_field_max_confidence_value(self): if hasattr(self, '_m_has_field_max_confidence_value'): return self._m_has_field_max_confidence_value self._m_has_field_max_confidence_value = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_max_confidence_value', None) @property def has_field_temperament_map(self): if hasattr(self, '_m_has_field_temperament_map'): return self._m_has_field_temperament_map self._m_has_field_temperament_map = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_temperament_map', None) class EShaderPlusComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SalvageOverAllExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopInteractionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_auto: self.is_auto = self._io.read_u1() @property def has_field_is_auto(self): if hasattr(self, '_m_has_field_is_auto'): return self._m_has_field_is_auto self._m_has_field_is_auto = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_auto', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ExpeditionBonusExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_level: self.avatar_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_probability: self.probability = self._io.read_f4le() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_avatar_level(self): if hasattr(self, '_m_has_field_avatar_level'): return self._m_has_field_avatar_level self._m_has_field_avatar_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_level', None) @property def has_field_probability(self): if hasattr(self, '_m_has_field_probability'): return self._m_has_field_probability self._m_has_field_probability = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_probability', None) class EnumPushTipsType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PushTipsType, self.data.value) return getattr(self, '_m_value', None) class VisionLevelTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiReactActionPointSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiReactActionPointData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiReactActionPointData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = self._io.read_f4le() if self.has_field_enter_radius: self.enter_radius = self._io.read_f4le() if self.has_field_exit_radius: self.exit_radius = self._io.read_f4le() if self.has_field_height_adjust: self.height_adjust = self._io.read_f4le() if self.has_field_fov: self.fov = self._io.read_f4le() if self.has_field_zoom: self.zoom = self._io.read_f4le() if self.has_field_spherical_y: self.spherical_y = self._io.read_f4le() if self.has_field_lock_spherical_y: self.lock_spherical_y = self._io.read_u1() if self.has_field_spherical_y_up: self.spherical_y_up = self._io.read_f4le() if self.has_field_spherical_y_down: self.spherical_y_down = self._io.read_f4le() if self.has_field_auto_turn_start_min: self.auto_turn_start_min = self._io.read_f4le() if self.has_field_auto_turn_start_max: self.auto_turn_start_max = self._io.read_f4le() if self.has_field_auto_turn_end_min: self.auto_turn_end_min = self._io.read_f4le() if self.has_field_auto_turn_end_max: self.auto_turn_end_max = self._io.read_f4le() if self.has_field_enter_shape: self.enter_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_exit_shape: self.exit_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_shape_center_offset: self.shape_center_offset = Output.Vector(self._io, self, self._root) @property def has_field_zoom(self): if hasattr(self, '_m_has_field_zoom'): return self._m_has_field_zoom self._m_has_field_zoom = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_zoom', None) @property def has_field_auto_turn_start_min(self): if hasattr(self, '_m_has_field_auto_turn_start_min'): return self._m_has_field_auto_turn_start_min self._m_has_field_auto_turn_start_min = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_auto_turn_start_min', None) @property def has_field_exit_shape(self): if hasattr(self, '_m_has_field_exit_shape'): return self._m_has_field_exit_shape self._m_has_field_exit_shape = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_exit_shape', None) @property def has_field_spherical_y_down(self): if hasattr(self, '_m_has_field_spherical_y_down'): return self._m_has_field_spherical_y_down self._m_has_field_spherical_y_down = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_spherical_y_down', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_auto_turn_end_max(self): if hasattr(self, '_m_has_field_auto_turn_end_max'): return self._m_has_field_auto_turn_end_max self._m_has_field_auto_turn_end_max = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_auto_turn_end_max', None) @property def has_field_exit_radius(self): if hasattr(self, '_m_has_field_exit_radius'): return self._m_has_field_exit_radius self._m_has_field_exit_radius = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_exit_radius', None) @property def has_field_spherical_y_up(self): if hasattr(self, '_m_has_field_spherical_y_up'): return self._m_has_field_spherical_y_up self._m_has_field_spherical_y_up = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_spherical_y_up', None) @property def has_field_spherical_y(self): if hasattr(self, '_m_has_field_spherical_y'): return self._m_has_field_spherical_y self._m_has_field_spherical_y = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_spherical_y', None) @property def has_field_enter_shape(self): if hasattr(self, '_m_has_field_enter_shape'): return self._m_has_field_enter_shape self._m_has_field_enter_shape = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_enter_shape', None) @property def has_field_auto_turn_start_max(self): if hasattr(self, '_m_has_field_auto_turn_start_max'): return self._m_has_field_auto_turn_start_max self._m_has_field_auto_turn_start_max = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_auto_turn_start_max', None) @property def has_field_lock_spherical_y(self): if hasattr(self, '_m_has_field_lock_spherical_y'): return self._m_has_field_lock_spherical_y self._m_has_field_lock_spherical_y = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_lock_spherical_y', None) @property def has_field_enter_radius(self): if hasattr(self, '_m_has_field_enter_radius'): return self._m_has_field_enter_radius self._m_has_field_enter_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_enter_radius', None) @property def has_field_shape_center_offset(self): if hasattr(self, '_m_has_field_shape_center_offset'): return self._m_has_field_shape_center_offset self._m_has_field_shape_center_offset = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_shape_center_offset', None) @property def has_field_height_adjust(self): if hasattr(self, '_m_has_field_height_adjust'): return self._m_has_field_height_adjust self._m_has_field_height_adjust = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_height_adjust', None) @property def has_field_fov(self): if hasattr(self, '_m_has_field_fov'): return self._m_has_field_fov self._m_has_field_fov = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_fov', None) @property def has_field_auto_turn_end_min(self): if hasattr(self, '_m_has_field_auto_turn_end_min'): return self._m_has_field_auto_turn_end_min self._m_has_field_auto_turn_end_min = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_auto_turn_end_min', None) class MichiaeDarkChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumNeuronNameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumNeuronName(self._io, self, self._root)) class SetWeaponAttachPointRealName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_part_name: self.part_name = AuxTypes.String(self._io, self, self._root) if self.has_field_real_name: self.real_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_real_name(self): if hasattr(self, '_m_has_field_real_name'): return self._m_has_field_real_name self._m_has_field_real_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_real_name', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_part_name(self): if hasattr(self, '_m_has_field_part_name'): return self._m_has_field_part_name self._m_has_field_part_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_part_name', None) class ArrayOfConfigHomeworldFurnitureDefaultSaveLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldFurnitureDefaultSave(self._io, self, self._root)) class AttachModifierToSelfGlobalValueAndTalkStateNoInitMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.AttachModifierToSelfGlobalValueNoInitMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gv_in_talk: self.gv_in_talk = AuxTypes.DynamicFloat(self._io, self, self._root) @property def global_value_key(self): if hasattr(self, '_m_global_value_key'): return self._m_global_value_key self._m_global_value_key = self.base.global_value_key return getattr(self, '_m_global_value_key', None) @property def action_queues(self): if hasattr(self, '_m_action_queues'): return self._m_action_queues self._m_action_queues = self.base.action_queues return getattr(self, '_m_action_queues', None) @property def value_steps(self): if hasattr(self, '_m_value_steps'): return self._m_value_steps self._m_value_steps = self.base.value_steps return getattr(self, '_m_value_steps', None) @property def remove_applied_modifier(self): if hasattr(self, '_m_remove_applied_modifier'): return self._m_remove_applied_modifier self._m_remove_applied_modifier = self.base.remove_applied_modifier return getattr(self, '_m_remove_applied_modifier', None) @property def modifier_name_steps(self): if hasattr(self, '_m_modifier_name_steps'): return self._m_modifier_name_steps self._m_modifier_name_steps = self.base.modifier_name_steps return getattr(self, '_m_modifier_name_steps', None) @property def has_field_gv_in_talk(self): if hasattr(self, '_m_has_field_gv_in_talk'): return self._m_has_field_gv_in_talk self._m_has_field_gv_in_talk = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gv_in_talk', None) @property def add_action(self): if hasattr(self, '_m_add_action'): return self._m_add_action self._m_add_action = self.base.add_action return getattr(self, '_m_add_action', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicUInt32multiCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_values: self.values = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_values(self): if hasattr(self, '_m_has_field_values'): return self._m_has_field_values self._m_has_field_values = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_values', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class MusicEnemyCombatPhaseState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_combat_phase: self.combat_phase = Output.EnumConfigAiCombatPhase(self._io, self, self._root) if self.has_field_state_value: self.state_value = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_combat_phase(self): if hasattr(self, '_m_has_field_combat_phase'): return self._m_has_field_combat_phase self._m_has_field_combat_phase = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_combat_phase', None) @property def has_field_state_value(self): if hasattr(self, '_m_has_field_state_value'): return self._m_has_field_state_value self._m_has_field_state_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_value', None) class ShopmallGoodsSaleConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAnimationPauseByAbilityStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_states: self.ability_states = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) @property def has_field_ability_states(self): if hasattr(self, '_m_has_field_ability_states'): return self._m_has_field_ability_states self._m_has_field_ability_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_states', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigCustomLevelRoomExtraData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_occupy_pos: self.occupy_pos = Output.Vector(self._io, self, self._root) if self.has_field_occupy_bound: self.occupy_bound = Output.Vector(self._io, self, self._root) if self.has_field_pile_tags: self.pile_tags = Output.ArrayOfEnumPileTagLengthU(self._io, self, self._root) if self.has_field_is_gadget: self.is_gadget = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_rot: self.gadget_rot = Output.Vector(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_pile_tags(self): if hasattr(self, '_m_has_field_pile_tags'): return self._m_has_field_pile_tags self._m_has_field_pile_tags = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_pile_tags', None) @property def has_field_is_gadget(self): if hasattr(self, '_m_has_field_is_gadget'): return self._m_has_field_is_gadget self._m_has_field_is_gadget = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_gadget', None) @property def has_field_occupy_pos(self): if hasattr(self, '_m_has_field_occupy_pos'): return self._m_has_field_occupy_pos self._m_has_field_occupy_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_occupy_pos', None) @property def has_field_occupy_bound(self): if hasattr(self, '_m_has_field_occupy_bound'): return self._m_has_field_occupy_bound self._m_has_field_occupy_bound = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_occupy_bound', None) @property def has_field_gadget_rot(self): if hasattr(self, '_m_has_field_gadget_rot'): return self._m_has_field_gadget_rot self._m_has_field_gadget_rot = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_gadget_rot', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_index', None) class HomeWorldLimitShopCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_condition: self.condition = Output.EnumHomeWorldLimitShopCondType(self._io, self, self._root) if self.has_field_condition_param: self.condition_param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_condition(self): if hasattr(self, '_m_has_field_condition'): return self._m_has_field_condition self._m_has_field_condition = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_condition', None) @property def has_field_condition_param(self): if hasattr(self, '_m_has_field_condition_param'): return self._m_has_field_condition_param self._m_has_field_condition_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_condition_param', None) class ArrayOfFishStockLimitLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FishStockLimit(self._io, self, self._root)) class SetWeaponBindState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_place: self.place = self._io.read_u1() if self.has_field_equip_part_name: self.equip_part_name = AuxTypes.String(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_equip_part_name(self): if hasattr(self, '_m_has_field_equip_part_name'): return self._m_has_field_equip_part_name self._m_has_field_equip_part_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_equip_part_name', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_place(self): if hasattr(self, '_m_has_field_place'): return self._m_has_field_place self._m_has_field_place = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_place', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_born', None) class EnableHeadControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_blend: self.blend = self._io.read_u1() @property def has_field_blend(self): if hasattr(self, '_m_has_field_blend'): return self._m_has_field_blend self._m_has_field_blend = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_blend', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesStringConfigGraphicsRecommendSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigGraphicsRecommendSetting(self._io, self, self._root)) class AvatarShareCdSkillStart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_share_cd_type: self.share_cd_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_share_cd_type(self): if hasattr(self, '_m_has_field_share_cd_type'): return self._m_has_field_share_cd_type self._m_has_field_share_cd_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_share_cd_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class GuidePlatformTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EffigyConditionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigCodexQuestItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCodexQuestItem(self._io, self, self._root)) class ConfigWeather(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_drop_elem_balls: self.drop_elem_balls = Output.ArrayOfConfigElemBallLengthU(self._io, self, self._root) if self.has_field_shape_name: self.shape_name = AuxTypes.String(self._io, self, self._root) if self.has_field_position: self.position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_default_enviro: self.default_enviro = AuxTypes.String(self._io, self, self._root) if self.has_field_weather_list: self.weather_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_weather_weight_list: self.weather_weight_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_refresh_time: self.refresh_time = self._io.read_f4le() @property def has_field_default_enviro(self): if hasattr(self, '_m_has_field_default_enviro'): return self._m_has_field_default_enviro self._m_has_field_default_enviro = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_default_enviro', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_drop_elem_balls(self): if hasattr(self, '_m_has_field_drop_elem_balls'): return self._m_has_field_drop_elem_balls self._m_has_field_drop_elem_balls = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_drop_elem_balls', None) @property def has_field_weather_list(self): if hasattr(self, '_m_has_field_weather_list'): return self._m_has_field_weather_list self._m_has_field_weather_list = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_weather_list', None) @property def has_field_shape_name(self): if hasattr(self, '_m_has_field_shape_name'): return self._m_has_field_shape_name self._m_has_field_shape_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shape_name', None) @property def has_field_refresh_time(self): if hasattr(self, '_m_has_field_refresh_time'): return self._m_has_field_refresh_time self._m_has_field_refresh_time = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_refresh_time', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_weather_weight_list(self): if hasattr(self, '_m_has_field_weather_weight_list'): return self._m_has_field_weather_weight_list self._m_has_field_weather_weight_list = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_weather_weight_list', None) class ConfigWidgetToyTreasureMapDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radius_succ: self.radius_succ = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detect_range: self.detect_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_duration: self.gadget_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_radius_succ(self): if hasattr(self, '_m_has_field_radius_succ'): return self._m_has_field_radius_succ self._m_has_field_radius_succ = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius_succ', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_gadget_duration(self): if hasattr(self, '_m_has_field_gadget_duration'): return self._m_has_field_gadget_duration self._m_has_field_gadget_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_duration', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def has_field_detect_range(self): if hasattr(self, '_m_has_field_detect_range'): return self._m_has_field_detect_range self._m_has_field_detect_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_detect_range', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class EnumRotAngleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RotAngleType, self.data.value) return getattr(self, '_m_value', None) class RemoveModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class ByHitDamage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_damage: self.damage = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_use_origin_damage: self.use_origin_damage = self._io.read_u1() @property def has_field_damage(self): if hasattr(self, '_m_has_field_damage'): return self._m_has_field_damage self._m_has_field_damage = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_damage', None) @property def has_field_use_origin_damage(self): if hasattr(self, '_m_has_field_use_origin_damage'): return self._m_has_field_use_origin_damage self._m_has_field_use_origin_damage = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_origin_damage', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumLocalizationAssetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LocalizationAssetType, self.data.value) return getattr(self, '_m_value', None) class EnumInteractCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InteractCondType, self.data.value) return getattr(self, '_m_value', None) class DieTypeTipsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterMissionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NeuronNameComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryBuffDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuidePageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BoredEventExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForceTriggerJump(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ActivitySpiceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spice_id: self.spice_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_fetter_value: self.fetter_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_width: self.extra_width = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_extra_width(self): if hasattr(self, '_m_has_field_extra_width'): return self._m_has_field_extra_width self._m_has_field_extra_width = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_extra_width', None) @property def has_field_spice_id(self): if hasattr(self, '_m_has_field_spice_id'): return self._m_has_field_spice_id self._m_has_field_spice_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_spice_id', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_fetter_value(self): if hasattr(self, '_m_has_field_fetter_value'): return self._m_has_field_fetter_value self._m_has_field_fetter_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fetter_value', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class DispIndicatorCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.IndicatorCondition(self._io, self, self._root) elif _on == 4: self.data = Output.IndicatorConditionAvatarDistance(self._io, self, self._root) elif _on == 6: self.data = Output.IndicatorConditionPlayerLevel(self._io, self, self._root) elif _on == 7: self.data = Output.IndicatorConditionSceneTransPointLockState(self._io, self, self._root) elif _on == 1: self.data = Output.IndicatorConditionGadgetState(self._io, self, self._root) elif _on == 3: self.data = Output.IndicatorConditionDummyPointDistance(self._io, self, self._root) elif _on == 5: self.data = Output.IndicatorConditionKilled(self._io, self, self._root) elif _on == 2: self.data = Output.IndicatorConditionAllowInteract(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class KvpOfDictAuxTypesStringArrayOfDispConfigAudioEventCullingRuleBaseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfDispConfigAudioEventCullingRuleBaseLengthU(self._io, self, self._root) class ArrayOfConfigLevelAreaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelArea(self._io, self, self._root)) class SortModifierTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SceneBuildingPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_building_type: self.building_type = Output.EnumSceneBuildingType(self._io, self, self._root) if self.has_field_fog_id: self.fog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_on_locked_area: self.show_on_locked_area = self._io.read_u1() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_building_type(self): if hasattr(self, '_m_has_field_building_type'): return self._m_has_field_building_type self._m_has_field_building_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_building_type', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_fog_id(self): if hasattr(self, '_m_has_field_fog_id'): return self._m_has_field_fog_id self._m_has_field_fog_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fog_id', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_show_on_locked_area(self): if hasattr(self, '_m_has_field_show_on_locked_area'): return self._m_has_field_show_on_locked_area self._m_has_field_show_on_locked_area = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_show_on_locked_area', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class ConfigAudioPositionedEmitterOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioPositionedOp(self._io, self, self._root) @property def positioning(self): if hasattr(self, '_m_positioning'): return self._m_positioning self._m_positioning = self.base.positioning return getattr(self, '_m_positioning', None) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class BounceConjuringChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_id: self.draft_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_other_ball_list: self.other_ball_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_new_ball_list: self.new_ball_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_other_item_list: self.other_item_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_up_item_list: self.up_item_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_other_item_list(self): if hasattr(self, '_m_has_field_other_item_list'): return self._m_has_field_other_item_list self._m_has_field_other_item_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_other_item_list', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_pos', None) @property def has_field_up_item_list(self): if hasattr(self, '_m_has_field_up_item_list'): return self._m_has_field_up_item_list self._m_has_field_up_item_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_up_item_list', None) @property def has_field_draft_id(self): if hasattr(self, '_m_has_field_draft_id'): return self._m_has_field_draft_id self._m_has_field_draft_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_draft_id', None) @property def has_field_other_ball_list(self): if hasattr(self, '_m_has_field_other_ball_list'): return self._m_has_field_other_ball_list self._m_has_field_other_ball_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_other_ball_list', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_new_ball_list(self): if hasattr(self, '_m_has_field_new_ball_list'): return self._m_has_field_new_ball_list self._m_has_field_new_ball_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_new_ball_list', None) class MichiaeDarkChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_challenge_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) class IrodoriQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_ids: self.main_quest_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_type: self.quest_type = Output.EnumLunaRiteQuestType(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter: self.chapter = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_other_quest_ids: self.pre_other_quest_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_pre_other_quest_ids(self): if hasattr(self, '_m_has_field_pre_other_quest_ids'): return self._m_has_field_pre_other_quest_ids self._m_has_field_pre_other_quest_ids = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_pre_other_quest_ids', None) @property def has_field_main_quest_ids(self): if hasattr(self, '_m_has_field_main_quest_ids'): return self._m_has_field_main_quest_ids self._m_has_field_main_quest_ids = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_main_quest_ids', None) @property def has_field_chapter(self): if hasattr(self, '_m_has_field_chapter'): return self._m_has_field_chapter self._m_has_field_chapter = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_chapter', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_quest_type(self): if hasattr(self, '_m_has_field_quest_type'): return self._m_has_field_quest_type self._m_has_field_quest_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_type', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class HitLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FindHilichurlAssignmentExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_assignment_type: self.assignment_type = Output.EnumFindHilichurlAssignmentType(self._io, self, self._root) if self.has_field_key_word: self.key_word = AuxTypes.String(self._io, self, self._root) if self.has_field_hint_sub_quest_id: self.hint_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_key_word(self): if hasattr(self, '_m_has_field_key_word'): return self._m_has_field_key_word self._m_has_field_key_word = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_key_word', None) @property def has_field_hint_sub_quest_id(self): if hasattr(self, '_m_has_field_hint_sub_quest_id'): return self._m_has_field_hint_sub_quest_id self._m_has_field_hint_sub_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_hint_sub_quest_id', None) @property def has_field_assignment_type(self): if hasattr(self, '_m_has_field_assignment_type'): return self._m_has_field_assignment_type self._m_has_field_assignment_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_assignment_type', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_index', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_day_index', None) class RoutineFinishTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LampPhaseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_phase_id: self.phase_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_progress: self.end_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_vec: self.material_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_giving_id: self.giving_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_contribution: self.contribution = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_progress: self.add_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_display: self.is_display = self._io.read_u1() if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_notify_group_id: self.notify_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_display(self): if hasattr(self, '_m_has_field_is_display'): return self._m_has_field_is_display self._m_has_field_is_display = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_display', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_material_vec(self): if hasattr(self, '_m_has_field_material_vec'): return self._m_has_field_material_vec self._m_has_field_material_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_material_vec', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_end_progress(self): if hasattr(self, '_m_has_field_end_progress'): return self._m_has_field_end_progress self._m_has_field_end_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_end_progress', None) @property def has_field_notify_group_id(self): if hasattr(self, '_m_has_field_notify_group_id'): return self._m_has_field_notify_group_id self._m_has_field_notify_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_notify_group_id', None) @property def has_field_phase_id(self): if hasattr(self, '_m_has_field_phase_id'): return self._m_has_field_phase_id self._m_has_field_phase_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_phase_id', None) @property def has_field_add_progress(self): if hasattr(self, '_m_has_field_add_progress'): return self._m_has_field_add_progress self._m_has_field_add_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_add_progress', None) @property def has_field_giving_id(self): if hasattr(self, '_m_has_field_giving_id'): return self._m_has_field_giving_id self._m_has_field_giving_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_giving_id', None) @property def has_field_contribution(self): if hasattr(self, '_m_has_field_contribution'): return self._m_has_field_contribution self._m_has_field_contribution = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_contribution', None) class SphereTileShapeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TileShapeInfo(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) class EnumGatherAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GatherAreaType, self.data.value) return getattr(self, '_m_value', None) class ConfigMonsterInitialPose(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_initial_pose_id: self.initial_pose_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_released: self.released = self._io.read_u1() if self.has_field_initial_pose_params: self.initial_pose_params = Output.ConfigPoseInitialParam(self._io, self, self._root) @property def has_field_initial_pose_id(self): if hasattr(self, '_m_has_field_initial_pose_id'): return self._m_has_field_initial_pose_id self._m_has_field_initial_pose_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_initial_pose_id', None) @property def has_field_released(self): if hasattr(self, '_m_has_field_released'): return self._m_has_field_released self._m_has_field_released = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_released', None) @property def has_field_initial_pose_params(self): if hasattr(self, '_m_has_field_initial_pose_params'): return self._m_has_field_initial_pose_params self._m_has_field_initial_pose_params = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_initial_pose_params', None) class RogueGadgetWidgetConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_weight', None) class EnumCoopTaskCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopTaskCondType, self.data.value) return getattr(self, '_m_value', None) class ChannellerSlabLoopDungeonPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRejectEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RejectEventType, self.data.value) return getattr(self, '_m_value', None) class ModifierStackingComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LampProgressControlConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActivityGroupLinkRewardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGroupLinkRewardType, self.data.value) return getattr(self, '_m_value', None) class SalesmanSpecialReward(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_type: self.reward_type = Output.EnumSalesmanSpecialRewardType(self._io, self, self._root) if self.has_field_obtain_method: self.obtain_method = Output.EnumSalesmanSpecialRewardObtainMethod(self._io, self, self._root) if self.has_field_obtain_param: self.obtain_param = AuxTypes.String(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_id: self.preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_preview_id(self): if hasattr(self, '_m_has_field_preview_id'): return self._m_has_field_preview_id self._m_has_field_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_preview_id', None) @property def has_field_obtain_param(self): if hasattr(self, '_m_has_field_obtain_param'): return self._m_has_field_obtain_param self._m_has_field_obtain_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_obtain_param', None) @property def has_field_obtain_method(self): if hasattr(self, '_m_has_field_obtain_method'): return self._m_has_field_obtain_method self._m_has_field_obtain_method = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_obtain_method', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_reward_type(self): if hasattr(self, '_m_has_field_reward_type'): return self._m_has_field_reward_type self._m_has_field_reward_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_type', None) class EnumProjectionGameGuideInputMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProjectionGameGuideInputMode, self.data.value) return getattr(self, '_m_value', None) class ConfigMusicFloatStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_float_param: self.float_param = self._io.read_f4le() @property def has_field_float_param(self): if hasattr(self, '_m_has_field_float_param'): return self._m_has_field_float_param self._m_has_field_float_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_float_param', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class ConfigLevelMonsterData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monsters: self.monsters = Output.ArrayOfConfigLevelMonsterUnitLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_monsters(self): if hasattr(self, '_m_has_field_monsters'): return self._m_has_field_monsters self._m_has_field_monsters = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_monsters', None) class LanV2projectionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBattleFervorUpdateTriggerByElementArt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cd: self.cd = self._io.read_f4le() @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cd', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class CustomLevelTagSortConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityCrystalLinkLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BrickTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReliquaryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MapAreaConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_area_id_1: self.area_id_1 = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_scene_point_id: self.scene_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_area_state: self.map_area_state = Output.EnumMapAreaState(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_area_id_1(self): if hasattr(self, '_m_has_field_area_id_1'): return self._m_has_field_area_id_1 self._m_has_field_area_id_1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_area_id_1', None) @property def has_field_scene_point_id(self): if hasattr(self, '_m_has_field_scene_point_id'): return self._m_has_field_scene_point_id self._m_has_field_scene_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_scene_point_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_map_area_state(self): if hasattr(self, '_m_has_field_map_area_state'): return self._m_has_field_map_area_state self._m_has_field_map_area_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_map_area_state', None) class ConfigAiCommandSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_accept_command_i_ds: self.accept_command_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_accept_command_i_ds(self): if hasattr(self, '_m_has_field_accept_command_i_ds'): return self._m_has_field_accept_command_i_ds self._m_has_field_accept_command_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_accept_command_i_ds', None) class ActTimeSlow(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_time_slow: self.time_slow = Output.ConfigTimeSlow(self._io, self, self._root) if self.has_field_is_global: self.is_global = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_time_slow(self): if hasattr(self, '_m_has_field_time_slow'): return self._m_has_field_time_slow self._m_has_field_time_slow = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time_slow', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_is_global(self): if hasattr(self, '_m_has_field_is_global'): return self._m_has_field_is_global self._m_has_field_is_global = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_global', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigTeleportToAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_forward: self.forward = Output.Vector(self._io, self, self._root) if self.has_field_open_long_dis_teleport: self.open_long_dis_teleport = self._io.read_u1() if self.has_field_sync_forward: self.sync_forward = self._io.read_u1() @property def has_field_forward(self): if hasattr(self, '_m_has_field_forward'): return self._m_has_field_forward self._m_has_field_forward = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_forward', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_open_long_dis_teleport(self): if hasattr(self, '_m_has_field_open_long_dis_teleport'): return self._m_has_field_open_long_dis_teleport self._m_has_field_open_long_dis_teleport = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_open_long_dis_teleport', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_sync_forward(self): if hasattr(self, '_m_has_field_sync_forward'): return self._m_has_field_sync_forward self._m_has_field_sync_forward = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_sync_forward', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class RogueDiaryRoundRoomExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlessingScanPicExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShadowQualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PriceTierConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tier_name: self.tier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_vip_point: self.vip_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tier_name(self): if hasattr(self, '_m_has_field_tier_name'): return self._m_has_field_tier_name self._m_has_field_tier_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tier_name', None) @property def has_field_vip_point(self): if hasattr(self, '_m_has_field_vip_point'): return self._m_has_field_vip_point self._m_has_field_vip_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_vip_point', None) class AsterMidExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_vec: self.camp_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_camp_vec(self): if hasattr(self, '_m_has_field_camp_vec'): return self._m_has_field_camp_vec self._m_has_field_camp_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_camp_vec', None) class ExpeditionOpenCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumExpeditionOpenCondType(self._io, self, self._root) if self.has_field_para: self.para = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_para2: self.para2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_para(self): if hasattr(self, '_m_has_field_para'): return self._m_has_field_para self._m_has_field_para = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_para', None) @property def has_field_para2(self): if hasattr(self, '_m_has_field_para2'): return self._m_has_field_para2 self._m_has_field_para2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_para2', None) class ByGameTimeIsLocked(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_locked: self.is_locked = self._io.read_u1() @property def has_field_is_locked(self): if hasattr(self, '_m_has_field_is_locked'): return self._m_has_field_is_locked self._m_has_field_is_locked = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_locked', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumTeamResonanceCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TeamResonanceCondType, self.data.value) return getattr(self, '_m_value', None) class KillSelfTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterLandMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_motion_change: self.on_motion_change = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_drop_to_pos: self.drop_to_pos = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_speed_bezier_type: self.drop_speed_bezier_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_has_drop_pos: self.has_drop_pos = self._io.read_u1() if self.has_field_drop_time: self.drop_time = self._io.read_f4le() if self.has_field_drop_speed: self.drop_speed = self._io.read_f4le() @property def has_field_drop_speed_bezier_type(self): if hasattr(self, '_m_has_field_drop_speed_bezier_type'): return self._m_has_field_drop_speed_bezier_type self._m_has_field_drop_speed_bezier_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_drop_speed_bezier_type', None) @property def has_field_drop_speed(self): if hasattr(self, '_m_has_field_drop_speed'): return self._m_has_field_drop_speed self._m_has_field_drop_speed = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_drop_speed', None) @property def has_field_drop_time(self): if hasattr(self, '_m_has_field_drop_time'): return self._m_has_field_drop_time self._m_has_field_drop_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_drop_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_has_drop_pos(self): if hasattr(self, '_m_has_field_has_drop_pos'): return self._m_has_field_has_drop_pos self._m_has_field_has_drop_pos = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_has_drop_pos', None) @property def has_field_on_motion_change(self): if hasattr(self, '_m_has_field_on_motion_change'): return self._m_has_field_on_motion_change self._m_has_field_on_motion_change = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_motion_change', None) @property def has_field_drop_to_pos(self): if hasattr(self, '_m_has_field_drop_to_pos'): return self._m_has_field_drop_to_pos self._m_has_field_drop_to_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_drop_to_pos', None) class ConfigTimer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_life_infinite: self.life_infinite = self._io.read_u1() if self.has_field_start_check_time: self.start_check_time = self._io.read_f4le() if self.has_field_check_interval: self.check_interval = self._io.read_f4le() if self.has_field_life_time: self.life_time = self._io.read_f4le() @property def has_field_life_infinite(self): if hasattr(self, '_m_has_field_life_infinite'): return self._m_has_field_life_infinite self._m_has_field_life_infinite = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_life_infinite', None) @property def has_field_start_check_time(self): if hasattr(self, '_m_has_field_start_check_time'): return self._m_has_field_start_check_time self._m_has_field_start_check_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_check_time', None) @property def has_field_check_interval(self): if hasattr(self, '_m_has_field_check_interval'): return self._m_has_field_check_interval self._m_has_field_check_interval = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_check_interval', None) @property def has_field_life_time(self): if hasattr(self, '_m_has_field_life_time'): return self._m_has_field_life_time self._m_has_field_life_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_life_time', None) class ArrayOfModifierWithPredicatesLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ModifierWithPredicates(self._io, self, self._root)) class FireworksReformParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSArrayOfEnumAiTargetSystemTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSArrayOfEnumAiTargetSystemTypeLengthU(self._io, self, self._root)) class EnumEmoBackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EmoBackType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigPerfNumberArrayItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberArrayItemOptionArrayInfo(self._io, self, self._root) class EchoShellTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumStackMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StackMethod, self.data.value) return getattr(self, '_m_value', None) class ByBigTeamWeaponTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActivitySumoDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarUseTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RecordRendererGlobalParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_floats: self.floats = Output.ArrayOfRendererFloatLengthU(self._io, self, self._root) @property def has_field_floats(self): if hasattr(self, '_m_has_field_floats'): return self._m_has_field_floats self._m_has_field_floats = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_floats', None) class ConfigAiCombatFixedMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_point_type: self.point_type = Output.EnumActionPointType(self._io, self, self._root) if self.has_field_cd_action_point: self.cd_action_point = self._io.read_f4le() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_detect_distance: self.detect_distance = self._io.read_f4le() if self.has_field_overtime: self.overtime = self._io.read_f4le() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_overtime(self): if hasattr(self, '_m_has_field_overtime'): return self._m_has_field_overtime self._m_has_field_overtime = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_overtime', None) @property def has_field_cd_action_point(self): if hasattr(self, '_m_has_field_cd_action_point'): return self._m_has_field_cd_action_point self._m_has_field_cd_action_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_action_point', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_type', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_detect_distance(self): if hasattr(self, '_m_has_field_detect_distance'): return self._m_has_field_detect_distance self._m_has_field_detect_distance = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_detect_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ConfigRecordEmoFunc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumEmoRecordTypeEnum(self._io, self, self._root) if self.has_field_record_bool: self.record_bool = self._io.read_u1() if self.has_field_record_float: self.record_float = self._io.read_f4le() if self.has_field_string_arrays: self.string_arrays = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ulongs: self.ulongs = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_string_arrays(self): if hasattr(self, '_m_has_field_string_arrays'): return self._m_has_field_string_arrays self._m_has_field_string_arrays = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_string_arrays', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_ulongs(self): if hasattr(self, '_m_has_field_ulongs'): return self._m_has_field_ulongs self._m_has_field_ulongs = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ulongs', None) @property def has_field_record_float(self): if hasattr(self, '_m_has_field_record_float'): return self._m_has_field_record_float self._m_has_field_record_float = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_record_float', None) @property def has_field_record_bool(self): if hasattr(self, '_m_has_field_record_bool'): return self._m_has_field_record_bool self._m_has_field_record_bool = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_record_bool', None) class ArrayOfConfigCrowdGroupColliderInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdGroupColliderInfo(self._io, self, self._root)) class EnumQState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QState, self.data.value) return getattr(self, '_m_value', None) class MoveToDirectionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AnimalDescribeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) class ConfigAiDefendArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_defend_range: self.defend_range = self._io.read_f4le() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_defend_range(self): if hasattr(self, '_m_has_field_defend_range'): return self._m_has_field_defend_range self._m_has_field_defend_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_defend_range', None) class BlossomSectionOrderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_section_id: self.section_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_section_id(self): if hasattr(self, '_m_has_field_section_id'): return self._m_has_field_section_id self._m_has_field_section_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_section_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_order', None) class HuntingRefreshCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomItemConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_count', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) class FollowAttachOccupyPriorityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiThreatScoreBaseSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_min: self.min = self._io.read_f4le() if self.has_field_max: self.max = self._io.read_f4le() if self.has_field_compare_operation: self.compare_operation = Output.EnumOrderingType(self._io, self, self._root) @property def has_field_compare_operation(self): if hasattr(self, '_m_has_field_compare_operation'): return self._m_has_field_compare_operation self._m_has_field_compare_operation = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_compare_operation', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min', None) class EnumDropElemBallType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DropElemBallType, self.data.value) return getattr(self, '_m_value', None) class LogicOperationComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RqTalkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_way: self.begin_way = Output.EnumTalkBeginWay(self._io, self, self._root) if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_begin_cond_comb: self.begin_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_begin_cond: self.begin_cond = Output.ArrayOfTalkCondLengthS(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_talks: self.next_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_next_random_talks: self.next_random_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_random_talk_count: self.show_random_talk_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_init_dialog: self.init_dialog = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_perform_cfg: self.perform_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_hero_talk: self.hero_talk = Output.EnumTalkHeroType(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dont_block_daily: self.dont_block_daily = self._io.read_u1() @property def has_field_perform_cfg(self): if hasattr(self, '_m_has_field_perform_cfg'): return self._m_has_field_perform_cfg self._m_has_field_perform_cfg = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_perform_cfg', None) @property def has_field_init_dialog(self): if hasattr(self, '_m_has_field_init_dialog'): return self._m_has_field_init_dialog self._m_has_field_init_dialog = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_init_dialog', None) @property def has_field_begin_way(self): if hasattr(self, '_m_has_field_begin_way'): return self._m_has_field_begin_way self._m_has_field_begin_way = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_begin_way', None) @property def has_field_next_talks(self): if hasattr(self, '_m_has_field_next_talks'): return self._m_has_field_next_talks self._m_has_field_next_talks = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_next_talks', None) @property def has_field_begin_cond_comb(self): if hasattr(self, '_m_has_field_begin_cond_comb'): return self._m_has_field_begin_cond_comb self._m_has_field_begin_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_begin_cond_comb', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_next_random_talks(self): if hasattr(self, '_m_has_field_next_random_talks'): return self._m_has_field_next_random_talks self._m_has_field_next_random_talks = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_next_random_talks', None) @property def has_field_dont_block_daily(self): if hasattr(self, '_m_has_field_dont_block_daily'): return self._m_has_field_dont_block_daily self._m_has_field_dont_block_daily = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_dont_block_daily', None) @property def has_field_show_random_talk_count(self): if hasattr(self, '_m_has_field_show_random_talk_count'): return self._m_has_field_show_random_talk_count self._m_has_field_show_random_talk_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_show_random_talk_count', None) @property def has_field_begin_cond(self): if hasattr(self, '_m_has_field_begin_cond'): return self._m_has_field_begin_cond self._m_has_field_begin_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_begin_cond', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_active_mode', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hero_talk(self): if hasattr(self, '_m_has_field_hero_talk'): return self._m_has_field_hero_talk self._m_has_field_hero_talk = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_hero_talk', None) class DictOfEnumSceneBuildingTypeEnumMarkIconType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumSceneBuildingTypeEnumMarkIconType(self._io, self, self._root)) class ArrayOfConfigContentRestrictionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigContentRestriction(self._io, self, self._root)) class EnumStateCameraType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StateCameraType, self.data.value) return getattr(self, '_m_value', None) class EnableMainInterface(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigResonanceCutScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cutscene_index: self.cutscene_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vfx_ability: self.vfx_ability = AuxTypes.String(self._io, self, self._root) @property def has_field_cutscene_index(self): if hasattr(self, '_m_has_field_cutscene_index'): return self._m_has_field_cutscene_index self._m_has_field_cutscene_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cutscene_index', None) @property def has_field_vfx_ability(self): if hasattr(self, '_m_has_field_vfx_ability'): return self._m_has_field_vfx_ability self._m_has_field_vfx_ability = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_vfx_ability', None) class ConfigQteStepBaseComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalkCondEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumQuestCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class RandomQuestFilterTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMusicStimulus(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MusicStimulus, self.data.value) return getattr(self, '_m_value', None) class ConfigActivityDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class EnumAbilityEntityVisibleReason(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityEntityVisibleReason, self.data.value) return getattr(self, '_m_value', None) class H5activityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_h5activity_id: self.h5activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detail: self.detail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_list: self.cond_list = Output.ArrayOfH5activityCondConfigLengthS(self._io, self, self._root) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_cond_list(self): if hasattr(self, '_m_has_field_cond_list'): return self._m_has_field_cond_list self._m_has_field_cond_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cond_list', None) @property def has_field_detail(self): if hasattr(self, '_m_has_field_detail'): return self._m_has_field_detail self._m_has_field_detail = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_detail', None) @property def has_field_h5activity_id(self): if hasattr(self, '_m_has_field_h5activity_id'): return self._m_has_field_h5activity_id self._m_has_field_h5activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_h5activity_id', None) class AchievementExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_goal_id: self.goal_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_id: self.order_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_stage_achievement_id: self.pre_stage_achievement_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_show: self.is_show = Output.EnumShowType(self._io, self, self._root) if self.has_field_ps4group_id: self.ps4group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ps5group_id: self.ps5group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ps5title: self.ps5title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ttype: self.ttype = AuxTypes.String(self._io, self, self._root) if self.has_field_ps_trophy_id: self.ps_trophy_id = AuxTypes.String(self._io, self, self._root) if self.has_field_ps4trophy_id: self.ps4trophy_id = AuxTypes.String(self._io, self, self._root) if self.has_field_ps5trophy_id: self.ps5trophy_id = AuxTypes.String(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_finish_reward_id: self.finish_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_delete_watcher_after_finish: self.is_delete_watcher_after_finish = self._io.read_u1() if self.has_field_progress_show_type: self.progress_show_type = Output.EnumProgressShowType(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_ps5group_id(self): if hasattr(self, '_m_has_field_ps5group_id'): return self._m_has_field_ps5group_id self._m_has_field_ps5group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_ps5group_id', None) @property def has_field_is_delete_watcher_after_finish(self): if hasattr(self, '_m_has_field_is_delete_watcher_after_finish'): return self._m_has_field_is_delete_watcher_after_finish self._m_has_field_is_delete_watcher_after_finish = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_delete_watcher_after_finish', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_progress_show_type(self): if hasattr(self, '_m_has_field_progress_show_type'): return self._m_has_field_progress_show_type self._m_has_field_progress_show_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_progress_show_type', None) @property def has_field_ttype(self): if hasattr(self, '_m_has_field_ttype'): return self._m_has_field_ttype self._m_has_field_ttype = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_ttype', None) @property def has_field_ps5title(self): if hasattr(self, '_m_has_field_ps5title'): return self._m_has_field_ps5title self._m_has_field_ps5title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_ps5title', None) @property def has_field_order_id(self): if hasattr(self, '_m_has_field_order_id'): return self._m_has_field_order_id self._m_has_field_order_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order_id', None) @property def has_field_finish_reward_id(self): if hasattr(self, '_m_has_field_finish_reward_id'): return self._m_has_field_finish_reward_id self._m_has_field_finish_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_finish_reward_id', None) @property def has_field_ps4trophy_id(self): if hasattr(self, '_m_has_field_ps4trophy_id'): return self._m_has_field_ps4trophy_id self._m_has_field_ps4trophy_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_ps4trophy_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_goal_id(self): if hasattr(self, '_m_has_field_goal_id'): return self._m_has_field_goal_id self._m_has_field_goal_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_goal_id', None) @property def has_field_ps5trophy_id(self): if hasattr(self, '_m_has_field_ps5trophy_id'): return self._m_has_field_ps5trophy_id self._m_has_field_ps5trophy_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_ps5trophy_id', None) @property def has_field_pre_stage_achievement_id(self): if hasattr(self, '_m_has_field_pre_stage_achievement_id'): return self._m_has_field_pre_stage_achievement_id self._m_has_field_pre_stage_achievement_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pre_stage_achievement_id', None) @property def has_field_is_show(self): if hasattr(self, '_m_has_field_is_show'): return self._m_has_field_is_show self._m_has_field_is_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_show', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_ps4group_id(self): if hasattr(self, '_m_has_field_ps4group_id'): return self._m_has_field_ps4group_id self._m_has_field_ps4group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_ps4group_id', None) @property def has_field_ps_trophy_id(self): if hasattr(self, '_m_has_field_ps_trophy_id'): return self._m_has_field_ps_trophy_id self._m_has_field_ps_trophy_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_ps_trophy_id', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ConfigCameraMoveInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_pos_type: self.camera_pos_type = Output.EnumStoryCameraPosType(self._io, self, self._root) if self.has_field_cam_pos_offset: self.cam_pos_offset = Output.Vector(self._io, self, self._root) if self.has_field_near_length: self.near_length = self._io.read_f4le() if self.has_field_cam_target_type: self.cam_target_type = Output.EnumStoryCameraTargetType(self._io, self, self._root) if self.has_field_cam_forward_target_offset: self.cam_forward_target_offset = Output.Vector(self._io, self, self._root) if self.has_field_need_elev: self.need_elev = self._io.read_u1() if self.has_field_cam_fov: self.cam_fov = self._io.read_f4le() if self.has_field_cam_dutch: self.cam_dutch = self._io.read_f4le() if self.has_field_lerp_ratio: self.lerp_ratio = self._io.read_f4le() if self.has_field_lerp_pattern: self.lerp_pattern = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_camera_blend_type: self.camera_blend_type = Output.EnumTweenEaseType(self._io, self, self._root) if self.has_field_story_dither: self.story_dither = self._io.read_u1() if self.has_field_cut_frame_trans: self.cut_frame_trans = Output.ConfigFrameTransition(self._io, self, self._root) if self.has_field_need_z_axis_rotate: self.need_z_axis_rotate = self._io.read_u1() if self.has_field_rotate_angle: self.rotate_angle = self._io.read_f4le() if self.has_field_open_camera_dither: self.open_camera_dither = self._io.read_u1() if self.has_field_target_npc_alias: self.target_npc_alias = AuxTypes.String(self._io, self, self._root) if self.has_field_keep_camera_pos: self.keep_camera_pos = self._io.read_u1() if self.has_field_use_duration_when_exit_focus: self.use_duration_when_exit_focus = self._io.read_u1() if self.has_field_close_tree_leaf_dither: self.close_tree_leaf_dither = self._io.read_u1() if self.has_field_multi_target_npc_alias_array: self.multi_target_npc_alias_array = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_close_camera_displacement: self.close_camera_displacement = self._io.read_u1() if self.has_field_veg_interact_type: self.veg_interact_type = Output.EnumVegetationInteractType(self._io, self, self._root) @property def has_field_cut_frame_trans(self): if hasattr(self, '_m_has_field_cut_frame_trans'): return self._m_has_field_cut_frame_trans self._m_has_field_cut_frame_trans = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_cut_frame_trans', None) @property def has_field_cam_pos_offset(self): if hasattr(self, '_m_has_field_cam_pos_offset'): return self._m_has_field_cam_pos_offset self._m_has_field_cam_pos_offset = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_cam_pos_offset', None) @property def has_field_lerp_ratio(self): if hasattr(self, '_m_has_field_lerp_ratio'): return self._m_has_field_lerp_ratio self._m_has_field_lerp_ratio = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_lerp_ratio', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_lerp_pattern(self): if hasattr(self, '_m_has_field_lerp_pattern'): return self._m_has_field_lerp_pattern self._m_has_field_lerp_pattern = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_lerp_pattern', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_need_z_axis_rotate(self): if hasattr(self, '_m_has_field_need_z_axis_rotate'): return self._m_has_field_need_z_axis_rotate self._m_has_field_need_z_axis_rotate = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_need_z_axis_rotate', None) @property def has_field_close_tree_leaf_dither(self): if hasattr(self, '_m_has_field_close_tree_leaf_dither'): return self._m_has_field_close_tree_leaf_dither self._m_has_field_close_tree_leaf_dither = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_close_tree_leaf_dither', None) @property def has_field_need_elev(self): if hasattr(self, '_m_has_field_need_elev'): return self._m_has_field_need_elev self._m_has_field_need_elev = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_need_elev', None) @property def has_field_camera_pos_type(self): if hasattr(self, '_m_has_field_camera_pos_type'): return self._m_has_field_camera_pos_type self._m_has_field_camera_pos_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_camera_pos_type', None) @property def has_field_cam_dutch(self): if hasattr(self, '_m_has_field_cam_dutch'): return self._m_has_field_cam_dutch self._m_has_field_cam_dutch = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_cam_dutch', None) @property def has_field_multi_target_npc_alias_array(self): if hasattr(self, '_m_has_field_multi_target_npc_alias_array'): return self._m_has_field_multi_target_npc_alias_array self._m_has_field_multi_target_npc_alias_array = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_multi_target_npc_alias_array', None) @property def has_field_camera_blend_type(self): if hasattr(self, '_m_has_field_camera_blend_type'): return self._m_has_field_camera_blend_type self._m_has_field_camera_blend_type = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_camera_blend_type', None) @property def has_field_open_camera_dither(self): if hasattr(self, '_m_has_field_open_camera_dither'): return self._m_has_field_open_camera_dither self._m_has_field_open_camera_dither = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_open_camera_dither', None) @property def has_field_keep_camera_pos(self): if hasattr(self, '_m_has_field_keep_camera_pos'): return self._m_has_field_keep_camera_pos self._m_has_field_keep_camera_pos = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_keep_camera_pos', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_cam_target_type(self): if hasattr(self, '_m_has_field_cam_target_type'): return self._m_has_field_cam_target_type self._m_has_field_cam_target_type = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_cam_target_type', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_use_duration_when_exit_focus(self): if hasattr(self, '_m_has_field_use_duration_when_exit_focus'): return self._m_has_field_use_duration_when_exit_focus self._m_has_field_use_duration_when_exit_focus = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_use_duration_when_exit_focus', None) @property def has_field_rotate_angle(self): if hasattr(self, '_m_has_field_rotate_angle'): return self._m_has_field_rotate_angle self._m_has_field_rotate_angle = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_rotate_angle', None) @property def has_field_veg_interact_type(self): if hasattr(self, '_m_has_field_veg_interact_type'): return self._m_has_field_veg_interact_type self._m_has_field_veg_interact_type = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_veg_interact_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_cam_forward_target_offset(self): if hasattr(self, '_m_has_field_cam_forward_target_offset'): return self._m_has_field_cam_forward_target_offset self._m_has_field_cam_forward_target_offset = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_cam_forward_target_offset', None) @property def has_field_cam_fov(self): if hasattr(self, '_m_has_field_cam_fov'): return self._m_has_field_cam_fov self._m_has_field_cam_fov = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_cam_fov', None) @property def has_field_target_npc_alias(self): if hasattr(self, '_m_has_field_target_npc_alias'): return self._m_has_field_target_npc_alias self._m_has_field_target_npc_alias = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_target_npc_alias', None) @property def has_field_story_dither(self): if hasattr(self, '_m_has_field_story_dither'): return self._m_has_field_story_dither self._m_has_field_story_dither = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_story_dither', None) @property def has_field_near_length(self): if hasattr(self, '_m_has_field_near_length'): return self._m_has_field_near_length self._m_has_field_near_length = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_near_length', None) @property def has_field_close_camera_displacement(self): if hasattr(self, '_m_has_field_close_camera_displacement'): return self._m_has_field_close_camera_displacement self._m_has_field_close_camera_displacement = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_close_camera_displacement', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class NewActivityScoreShowExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_score', None) class ConfigVehicleAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetAudio(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_collision_event: self.collision_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_max_velocity: self.max_velocity = self._io.read_f4le() if self.has_field_collision_audio_trigger_cooldown: self.collision_audio_trigger_cooldown = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_collision_audio_trigger_threshold: self.collision_audio_trigger_threshold = self._io.read_f4le() @property def has_field_collision_audio_trigger_threshold(self): if hasattr(self, '_m_has_field_collision_audio_trigger_threshold'): return self._m_has_field_collision_audio_trigger_threshold self._m_has_field_collision_audio_trigger_threshold = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_collision_audio_trigger_threshold', None) @property def destroy_event(self): if hasattr(self, '_m_destroy_event'): return self._m_destroy_event self._m_destroy_event = self.base.destroy_event return getattr(self, '_m_destroy_event', None) @property def anim_audio(self): if hasattr(self, '_m_anim_audio'): return self._m_anim_audio self._m_anim_audio = self.base.anim_audio return getattr(self, '_m_anim_audio', None) @property def disable_event(self): if hasattr(self, '_m_disable_event'): return self._m_disable_event self._m_disable_event = self.base.disable_event return getattr(self, '_m_disable_event', None) @property def has_field_collision_audio_trigger_cooldown(self): if hasattr(self, '_m_has_field_collision_audio_trigger_cooldown'): return self._m_has_field_collision_audio_trigger_cooldown self._m_has_field_collision_audio_trigger_cooldown = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_collision_audio_trigger_cooldown', None) @property def enable_event(self): if hasattr(self, '_m_enable_event'): return self._m_enable_event self._m_enable_event = self.base.enable_event return getattr(self, '_m_enable_event', None) @property def has_field_collision_event(self): if hasattr(self, '_m_has_field_collision_event'): return self._m_has_field_collision_event self._m_has_field_collision_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_collision_event', None) @property def triggers_speech(self): if hasattr(self, '_m_triggers_speech'): return self._m_triggers_speech self._m_triggers_speech = self.base.triggers_speech return getattr(self, '_m_triggers_speech', None) @property def has_field_max_velocity(self): if hasattr(self, '_m_has_field_max_velocity'): return self._m_has_field_max_velocity self._m_has_field_max_velocity = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_velocity', None) @property def init_event(self): if hasattr(self, '_m_init_event'): return self._m_init_event self._m_init_event = self.base.init_event return getattr(self, '_m_init_event', None) class NavmeshModeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumEntityTokenActionTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumEntityTokenActionType(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class EnumModifierTimeScale(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ModifierTimeScale, self.data.value) return getattr(self, '_m_value', None) class ArrayOfColorVectorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ColorVector(self._io, self, self._root)) class TalkLoadTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeightDetectRegionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_on_weight_changed: self.on_weight_changed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_on_weight_changed(self): if hasattr(self, '_m_has_field_on_weight_changed'): return self._m_has_field_on_weight_changed self._m_has_field_on_weight_changed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_weight_changed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ChannellerSlabLoopDungeonDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumChannellerSlabDifficulty(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_ratio: self.score_ratio = self._io.read_f4le() if self.has_field_base_score: self.base_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_base_score(self): if hasattr(self, '_m_has_field_base_score'): return self._m_has_field_base_score self._m_has_field_base_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_base_score', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_score_ratio(self): if hasattr(self, '_m_has_field_score_ratio'): return self._m_has_field_score_ratio self._m_has_field_score_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_score_ratio', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class RoguelikeRuneExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_unlock: self.is_default_unlock = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rune_icon: self.rune_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_rune_icon1: self.rune_icon1 = AuxTypes.String(self._io, self, self._root) if self.has_field_rune_icon2: self.rune_icon2 = AuxTypes.String(self._io, self, self._root) if self.has_field_rune_icon3: self.rune_icon3 = AuxTypes.String(self._io, self, self._root) if self.has_field_default_use_count: self.default_use_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_element_type: self.element_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_rune_icon(self): if hasattr(self, '_m_has_field_rune_icon'): return self._m_has_field_rune_icon self._m_has_field_rune_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_rune_icon', None) @property def has_field_is_default_unlock(self): if hasattr(self, '_m_has_field_is_default_unlock'): return self._m_has_field_is_default_unlock self._m_has_field_is_default_unlock = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_default_unlock', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_rune_icon3(self): if hasattr(self, '_m_has_field_rune_icon3'): return self._m_has_field_rune_icon3 self._m_has_field_rune_icon3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_rune_icon3', None) @property def has_field_default_use_count(self): if hasattr(self, '_m_has_field_default_use_count'): return self._m_has_field_default_use_count self._m_has_field_default_use_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_default_use_count', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_rune_icon1(self): if hasattr(self, '_m_has_field_rune_icon1'): return self._m_has_field_rune_icon1 self._m_has_field_rune_icon1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_rune_icon1', None) @property def has_field_rune_icon2(self): if hasattr(self, '_m_has_field_rune_icon2'): return self._m_has_field_rune_icon2 self._m_has_field_rune_icon2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_rune_icon2', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_element_type', None) class ConfigGuidePressKeyCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_event_id: self.event_id = Output.EnumInputEventType(self._io, self, self._root) if self.has_field_end_event_id: self.end_event_id = Output.EnumInputEventType(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGuideKeyClick(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_end_event_id(self): if hasattr(self, '_m_has_field_end_event_id'): return self._m_has_field_end_event_id self._m_has_field_end_event_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_end_event_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def has_field_event_id(self): if hasattr(self, '_m_has_field_event_id'): return self._m_has_field_event_id self._m_has_field_event_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_event_id', None) class KvpOfDictAuxTypesStringConfigPerfCombinedItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfCombinedItem(self._io, self, self._root) class SetCrystalShieldHpToOverrideMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_map_key: self.override_map_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_map_key(self): if hasattr(self, '_m_has_field_override_map_key'): return self._m_has_field_override_map_key self._m_has_field_override_map_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_map_key', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringConfigCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigCombat(self._io, self, self._root) class ConfigJudgeEntityInViewData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_config_id: self.entity_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scannable_states: self.scannable_states = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_entity_config_id(self): if hasattr(self, '_m_has_field_entity_config_id'): return self._m_has_field_entity_config_id self._m_has_field_entity_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_config_id', None) @property def has_field_scannable_states(self): if hasattr(self, '_m_has_field_scannable_states'): return self._m_has_field_scannable_states self._m_has_field_scannable_states = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scannable_states', None) class MechanicusExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mechanicus_id: self.mechanicus_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sequence_list: self.sequence_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ticket_item_id: self.ticket_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ticket_cost_count: self.ticket_cost_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_player_limit: self.match_player_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_gear_list: self.open_gear_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_map_list: self.open_map_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_teach_difficult_level: self.teach_difficult_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_punish_time: self.punish_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_open_map_list(self): if hasattr(self, '_m_has_field_open_map_list'): return self._m_has_field_open_map_list self._m_has_field_open_map_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_open_map_list', None) @property def has_field_match_player_limit(self): if hasattr(self, '_m_has_field_match_player_limit'): return self._m_has_field_match_player_limit self._m_has_field_match_player_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_match_player_limit', None) @property def has_field_punish_time(self): if hasattr(self, '_m_has_field_punish_time'): return self._m_has_field_punish_time self._m_has_field_punish_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_punish_time', None) @property def has_field_mechanicus_id(self): if hasattr(self, '_m_has_field_mechanicus_id'): return self._m_has_field_mechanicus_id self._m_has_field_mechanicus_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mechanicus_id', None) @property def has_field_ticket_item_id(self): if hasattr(self, '_m_has_field_ticket_item_id'): return self._m_has_field_ticket_item_id self._m_has_field_ticket_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ticket_item_id', None) @property def has_field_sequence_list(self): if hasattr(self, '_m_has_field_sequence_list'): return self._m_has_field_sequence_list self._m_has_field_sequence_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sequence_list', None) @property def has_field_ticket_cost_count(self): if hasattr(self, '_m_has_field_ticket_cost_count'): return self._m_has_field_ticket_cost_count self._m_has_field_ticket_cost_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ticket_cost_count', None) @property def has_field_teach_difficult_level(self): if hasattr(self, '_m_has_field_teach_difficult_level'): return self._m_has_field_teach_difficult_level self._m_has_field_teach_difficult_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_teach_difficult_level', None) @property def has_field_open_gear_list(self): if hasattr(self, '_m_has_field_open_gear_list'): return self._m_has_field_open_gear_list self._m_has_field_open_gear_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_gear_list', None) class EnumGadgetState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetState, self.data.value) return getattr(self, '_m_value', None) class ConfigAiFleeOnBlockAvatarLandingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFleeOnBlockAvatarLandingData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFleeOnBlockAvatarLandingData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigUiPhotograph(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fov_max: self.fov_max = self._io.read_f4le() if self.has_field_fov_min: self.fov_min = self._io.read_f4le() if self.has_field_camera_shift_up: self.camera_shift_up = self._io.read_f4le() if self.has_field_camera_shift_down: self.camera_shift_down = self._io.read_f4le() if self.has_field_camera_shift_left: self.camera_shift_left = self._io.read_f4le() if self.has_field_camera_shift_right: self.camera_shift_right = self._io.read_f4le() if self.has_field_blur_distance: self.blur_distance = self._io.read_f4le() if self.has_field_blur_range: self.blur_range = self._io.read_f4le() if self.has_field_blur_amount: self.blur_amount = self._io.read_f4le() @property def has_field_camera_shift_up(self): if hasattr(self, '_m_has_field_camera_shift_up'): return self._m_has_field_camera_shift_up self._m_has_field_camera_shift_up = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_camera_shift_up', None) @property def has_field_blur_amount(self): if hasattr(self, '_m_has_field_blur_amount'): return self._m_has_field_blur_amount self._m_has_field_blur_amount = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_blur_amount', None) @property def has_field_camera_shift_right(self): if hasattr(self, '_m_has_field_camera_shift_right'): return self._m_has_field_camera_shift_right self._m_has_field_camera_shift_right = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_camera_shift_right', None) @property def has_field_camera_shift_left(self): if hasattr(self, '_m_has_field_camera_shift_left'): return self._m_has_field_camera_shift_left self._m_has_field_camera_shift_left = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_camera_shift_left', None) @property def has_field_camera_shift_down(self): if hasattr(self, '_m_has_field_camera_shift_down'): return self._m_has_field_camera_shift_down self._m_has_field_camera_shift_down = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_camera_shift_down', None) @property def has_field_blur_range(self): if hasattr(self, '_m_has_field_blur_range'): return self._m_has_field_blur_range self._m_has_field_blur_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_blur_range', None) @property def has_field_blur_distance(self): if hasattr(self, '_m_has_field_blur_distance'): return self._m_has_field_blur_distance self._m_has_field_blur_distance = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_blur_distance', None) @property def has_field_fov_min(self): if hasattr(self, '_m_has_field_fov_min'): return self._m_has_field_fov_min self._m_has_field_fov_min = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_fov_min', None) @property def has_field_fov_max(self): if hasattr(self, '_m_has_field_fov_max'): return self._m_has_field_fov_max self._m_has_field_fov_max = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_fov_max', None) class ConfigBornByGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_position_key: self.position_key = AuxTypes.String(self._io, self, self._root) if self.has_field_direction_key: self.direction_key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_global_up: self.use_global_up = self._io.read_u1() @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def has_field_position_key(self): if hasattr(self, '_m_has_field_position_key'): return self._m_has_field_position_key self._m_has_field_position_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position_key', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def has_field_use_global_up(self): if hasattr(self, '_m_has_field_use_global_up'): return self._m_has_field_use_global_up self._m_has_field_use_global_up = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_global_up', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def has_field_direction_key(self): if hasattr(self, '_m_has_field_direction_key'): return self._m_has_field_direction_key self._m_has_field_direction_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_direction_key', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigAvatarControllerAssemblySkillSubs(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_skill01_subs: self.skill01_subs = AuxTypes.String(self._io, self, self._root) if self.has_field_skill02_subs: self.skill02_subs = AuxTypes.String(self._io, self, self._root) if self.has_field_skill03_subs: self.skill03_subs = AuxTypes.String(self._io, self, self._root) if self.has_field_skill04_subs: self.skill04_subs = AuxTypes.String(self._io, self, self._root) @property def has_field_skill01_subs(self): if hasattr(self, '_m_has_field_skill01_subs'): return self._m_has_field_skill01_subs self._m_has_field_skill01_subs = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill01_subs', None) @property def has_field_skill02_subs(self): if hasattr(self, '_m_has_field_skill02_subs'): return self._m_has_field_skill02_subs self._m_has_field_skill02_subs = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill02_subs', None) @property def has_field_skill03_subs(self): if hasattr(self, '_m_has_field_skill03_subs'): return self._m_has_field_skill03_subs self._m_has_field_skill03_subs = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_skill03_subs', None) @property def has_field_skill04_subs(self): if hasattr(self, '_m_has_field_skill04_subs'): return self._m_has_field_skill04_subs self._m_has_field_skill04_subs = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_skill04_subs', None) class AbilityDefine(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForgeUnlockConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_unlock_method: self.unlock_method = Output.EnumForgeUnlockMethod(self._io, self, self._root) if self.has_field_unlock_param: self.unlock_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_unlock_method(self): if hasattr(self, '_m_has_field_unlock_method'): return self._m_has_field_unlock_method self._m_has_field_unlock_method = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_unlock_method', None) @property def has_field_unlock_param(self): if hasattr(self, '_m_has_field_unlock_param'): return self._m_has_field_unlock_param self._m_has_field_unlock_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_unlock_param', None) class MixinEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfTowerStarRewardLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TowerStarReward(self._io, self, self._root)) class TreeDropExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tree_type: self.tree_type = Output.EnumTreeType(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tree_type(self): if hasattr(self, '_m_has_field_tree_type'): return self._m_has_field_tree_type self._m_has_field_tree_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tree_type', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_drop_id', None) class SalvageOverAllExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_duration: self.activity_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_center: self.region_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_region_radius: self.region_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_radius: self.reminder_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_id: self.reminder_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_destory_radius: self.destory_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_land_reward_preview_id: self.land_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sea_reward_preview_id: self.sea_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_land_reward_preview_id(self): if hasattr(self, '_m_has_field_land_reward_preview_id'): return self._m_has_field_land_reward_preview_id self._m_has_field_land_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_land_reward_preview_id', None) @property def has_field_reminder_radius(self): if hasattr(self, '_m_has_field_reminder_radius'): return self._m_has_field_reminder_radius self._m_has_field_reminder_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reminder_radius', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_reminder_id(self): if hasattr(self, '_m_has_field_reminder_id'): return self._m_has_field_reminder_id self._m_has_field_reminder_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_reminder_id', None) @property def has_field_region_radius(self): if hasattr(self, '_m_has_field_region_radius'): return self._m_has_field_region_radius self._m_has_field_region_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_region_radius', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_activity_duration(self): if hasattr(self, '_m_has_field_activity_duration'): return self._m_has_field_activity_duration self._m_has_field_activity_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_duration', None) @property def has_field_region_center(self): if hasattr(self, '_m_has_field_region_center'): return self._m_has_field_region_center self._m_has_field_region_center = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_region_center', None) @property def has_field_destory_radius(self): if hasattr(self, '_m_has_field_destory_radius'): return self._m_has_field_destory_radius self._m_has_field_destory_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_destory_radius', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_sea_reward_preview_id(self): if hasattr(self, '_m_has_field_sea_reward_preview_id'): return self._m_has_field_sea_reward_preview_id self._m_has_field_sea_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_sea_reward_preview_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class IndicatorConditionAllowInteract(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_allow_interact: self.allow_interact = self._io.read_u1() @property def has_field_allow_interact(self): if hasattr(self, '_m_has_field_allow_interact'): return self._m_has_field_allow_interact self._m_has_field_allow_interact = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_allow_interact', None) class ConfigMusicUInt32listMemberCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class WidgetCameraScanExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_id: self.camera_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scannable_state: self.scannable_state = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_hint: self.is_hint = self._io.read_u1() if self.has_field_action: self.action = Output.EnumWidgetCameraActionType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_is_hint(self): if hasattr(self, '_m_has_field_is_hint'): return self._m_has_field_is_hint self._m_has_field_is_hint = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_hint', None) @property def has_field_action(self): if hasattr(self, '_m_has_field_action'): return self._m_has_field_action self._m_has_field_action = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_action', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_camera_id(self): if hasattr(self, '_m_has_field_camera_id'): return self._m_has_field_camera_id self._m_has_field_camera_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_camera_id', None) @property def has_field_scannable_state(self): if hasattr(self, '_m_has_field_scannable_state'): return self._m_has_field_scannable_state self._m_has_field_scannable_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_scannable_state', None) class FireAfterImage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_index: self.effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_index', None) class EnumSectrLayerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrLayerType, self.data.value) return getattr(self, '_m_value', None) class DungeonPassExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic_type: self.logic_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_conds: self.conds = Output.ArrayOfDungeonCondConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_logic_type(self): if hasattr(self, '_m_has_field_logic_type'): return self._m_has_field_logic_type self._m_has_field_logic_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_logic_type', None) @property def has_field_conds(self): if hasattr(self, '_m_has_field_conds'): return self._m_has_field_conds self._m_has_field_conds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_conds', None) class EnumDailyTaskCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DailyTaskCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigGloablMiscs(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_air_flow_acc: self.air_flow_acc = self._io.read_f4le() if self.has_field_paimon_gadget_id: self.paimon_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cure_effect: self.cure_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_avatar_focus: self.avatar_focus = Output.ConfigAvatarFocusGroup(self._io, self, self._root) if self.has_field_gadget_ui_cut_sence_cfg_path: self.gadget_ui_cut_sence_cfg_path = AuxTypes.String(self._io, self, self._root) if self.has_field_gadget_ui_camera_look_cfg_path: self.gadget_ui_camera_look_cfg_path = AuxTypes.String(self._io, self, self._root) if self.has_field_weapon_anim_curve_path: self.weapon_anim_curve_path = AuxTypes.String(self._io, self, self._root) @property def has_field_weapon_anim_curve_path(self): if hasattr(self, '_m_has_field_weapon_anim_curve_path'): return self._m_has_field_weapon_anim_curve_path self._m_has_field_weapon_anim_curve_path = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_weapon_anim_curve_path', None) @property def has_field_gadget_ui_camera_look_cfg_path(self): if hasattr(self, '_m_has_field_gadget_ui_camera_look_cfg_path'): return self._m_has_field_gadget_ui_camera_look_cfg_path self._m_has_field_gadget_ui_camera_look_cfg_path = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_gadget_ui_camera_look_cfg_path', None) @property def has_field_air_flow_acc(self): if hasattr(self, '_m_has_field_air_flow_acc'): return self._m_has_field_air_flow_acc self._m_has_field_air_flow_acc = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_air_flow_acc', None) @property def has_field_gadget_ui_cut_sence_cfg_path(self): if hasattr(self, '_m_has_field_gadget_ui_cut_sence_cfg_path'): return self._m_has_field_gadget_ui_cut_sence_cfg_path self._m_has_field_gadget_ui_cut_sence_cfg_path = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_gadget_ui_cut_sence_cfg_path', None) @property def has_field_cure_effect(self): if hasattr(self, '_m_has_field_cure_effect'): return self._m_has_field_cure_effect self._m_has_field_cure_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cure_effect', None) @property def has_field_avatar_focus(self): if hasattr(self, '_m_has_field_avatar_focus'): return self._m_has_field_avatar_focus self._m_has_field_avatar_focus = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_avatar_focus', None) @property def has_field_paimon_gadget_id(self): if hasattr(self, '_m_has_field_paimon_gadget_id'): return self._m_has_field_paimon_gadget_id self._m_has_field_paimon_gadget_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_paimon_gadget_id', None) class ConfigMusicStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_stimulus: self.stimulus = Output.EnumMusicStimulus(self._io, self, self._root) if self.has_field_transitions: self.transitions = Output.ConfigMusicTransitions(self._io, self, self._root) @property def has_field_stimulus(self): if hasattr(self, '_m_has_field_stimulus'): return self._m_has_field_stimulus self._m_has_field_stimulus = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stimulus', None) @property def has_field_transitions(self): if hasattr(self, '_m_has_field_transitions'): return self._m_has_field_transitions self._m_has_field_transitions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_transitions', None) class RadarHintExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radar_hint_type: self.radar_hint_type = Output.EnumRadarHintType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_offset_radius: self.offset_radius = self._io.read_f4le() if self.has_field_area_radius: self.area_radius = self._io.read_f4le() if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_audio_name: self.audio_name = AuxTypes.String(self._io, self, self._root) @property def has_field_radar_hint_type(self): if hasattr(self, '_m_has_field_radar_hint_type'): return self._m_has_field_radar_hint_type self._m_has_field_radar_hint_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_radar_hint_type', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_effect_name', None) @property def has_field_offset_radius(self): if hasattr(self, '_m_has_field_offset_radius'): return self._m_has_field_offset_radius self._m_has_field_offset_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_offset_radius', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_radius', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_area_radius(self): if hasattr(self, '_m_has_field_area_radius'): return self._m_has_field_area_radius self._m_has_field_area_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_area_radius', None) @property def has_field_audio_name(self): if hasattr(self, '_m_has_field_audio_name'): return self._m_has_field_audio_name self._m_has_field_audio_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_audio_name', None) class ItemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumActionTokenSourceTypeDictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumActionTokenSourceType(self._io, self, self._root) self.value = Output.DictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root) class ExhibitionScoreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series_id: self.series_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_type: self.score_type = Output.EnumExhibitionScoreType(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_out: self.show_out = self._io.read_u1() @property def has_field_score_type(self): if hasattr(self, '_m_has_field_score_type'): return self._m_has_field_score_type self._m_has_field_score_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_score_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_out(self): if hasattr(self, '_m_has_field_show_out'): return self._m_has_field_show_out self._m_has_field_show_out = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_out', None) @property def has_field_series_id(self): if hasattr(self, '_m_has_field_series_id'): return self._m_has_field_series_id self._m_has_field_series_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_series_id', None) class HideUiBillBoard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hide: self.hide = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_hide(self): if hasattr(self, '_m_has_field_hide'): return self._m_has_field_hide self._m_has_field_hide = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hide', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class TriggerAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_responder: self.responder = Output.EnumOpResponder(self._io, self, self._root) if self.has_field_operation: self.operation = Output.DispConfigAudioOperation(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_responder(self): if hasattr(self, '_m_has_field_responder'): return self._m_has_field_responder self._m_has_field_responder = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_responder', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_operation(self): if hasattr(self, '_m_has_field_operation'): return self._m_has_field_operation self._m_has_field_operation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_operation', None) class ConfigVBaseMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumMarkViewType(self._io, self, self._root) if self.has_field_res_path: self.res_path = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_res_path(self): if hasattr(self, '_m_has_field_res_path'): return self._m_has_field_res_path self._m_has_field_res_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_res_path', None) class TargetPositionAreaLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUConfigWidgetCdGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigWidgetCdGroup(self._io, self, self._root) class TowerSchedule(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_floor_list: self.floor_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_time: self.open_time = AuxTypes.String(self._io, self, self._root) @property def has_field_floor_list(self): if hasattr(self, '_m_has_field_floor_list'): return self._m_has_field_floor_list self._m_has_field_floor_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_floor_list', None) @property def has_field_open_time(self): if hasattr(self, '_m_has_field_open_time'): return self._m_has_field_open_time self._m_has_field_open_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_time', None) class ModifySkillCdByModifierCountMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_type: self.target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_delta: self.cd_delta = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_cd_delta(self): if hasattr(self, '_m_has_field_cd_delta'): return self._m_has_field_cd_delta self._m_has_field_cd_delta = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cd_delta', None) class PsActivitiesBaseConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_object_id: self.object_id = AuxTypes.String(self._io, self, self._root) if self.has_field_export_version: self.export_version = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_object_id(self): if hasattr(self, '_m_has_field_object_id'): return self._m_has_field_object_id self._m_has_field_object_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_object_id', None) @property def has_field_export_version(self): if hasattr(self, '_m_has_field_export_version'): return self._m_has_field_export_version self._m_has_field_export_version = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_export_version', None) class DictOfAuxTypesStringConfigPerfNumberArrayItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberArrayItem(self._io, self, self._root)) class ConfigGuideFinishQuestAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_id', None) class ConfigGuideAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseGuide(self._io, self, self._root) class ConfigFishingAimParabolaBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gravity: self.gravity = self._io.read_f4le() if self.has_field_init_speed: self.init_speed = self._io.read_f4le() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def has_field_gravity(self): if hasattr(self, '_m_has_field_gravity'): return self._m_has_field_gravity self._m_has_field_gravity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gravity', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) @property def has_field_init_speed(self): if hasattr(self, '_m_has_field_init_speed'): return self._m_has_field_init_speed self._m_has_field_init_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_init_speed', None) class ConfigStandbyPerform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_time: self.min_time = self._io.read_f4le() if self.has_field_max_time: self.max_time = self._io.read_f4le() if self.has_field_perform_i_ds: self.perform_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_min_time(self): if hasattr(self, '_m_has_field_min_time'): return self._m_has_field_min_time self._m_has_field_min_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_time', None) @property def has_field_max_time(self): if hasattr(self, '_m_has_field_max_time'): return self._m_has_field_max_time self._m_has_field_max_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_time', None) @property def has_field_perform_i_ds(self): if hasattr(self, '_m_has_field_perform_i_ds'): return self._m_has_field_perform_i_ds self._m_has_field_perform_i_ds = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_perform_i_ds', None) class MichiaeAntiErosionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_foundation_level: self.foundation_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_b1: self.b1 = self._io.read_f4le() if self.has_field_b2: self.b2 = self._io.read_f4le() if self.has_field_b3: self.b3 = self._io.read_f4le() if self.has_field_crystal_energy_max_limit: self.crystal_energy_max_limit = self._io.read_f4le() @property def has_field_crystal_energy_max_limit(self): if hasattr(self, '_m_has_field_crystal_energy_max_limit'): return self._m_has_field_crystal_energy_max_limit self._m_has_field_crystal_energy_max_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_crystal_energy_max_limit', None) @property def has_field_b3(self): if hasattr(self, '_m_has_field_b3'): return self._m_has_field_b3 self._m_has_field_b3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_b3', None) @property def has_field_b2(self): if hasattr(self, '_m_has_field_b2'): return self._m_has_field_b2 self._m_has_field_b2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_b2', None) @property def has_field_b1(self): if hasattr(self, '_m_has_field_b1'): return self._m_has_field_b1 self._m_has_field_b1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_b1', None) @property def has_field_foundation_level(self): if hasattr(self, '_m_has_field_foundation_level'): return self._m_has_field_foundation_level self._m_has_field_foundation_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_foundation_level', None) class DictOfAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root)) class ConfigWidget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_widgets: self.widgets = Output.DictOfAuxTypesStringDispConfigBaseWidget(self._io, self, self._root) @property def has_field_widgets(self): if hasattr(self, '_m_has_field_widgets'): return self._m_has_field_widgets self._m_has_field_widgets = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_widgets', None) class VehicleSkillDepotChangeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_vehicle_i_ds: self.target_vehicle_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_skill_depot_id: self.skill_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_target_vehicle_i_ds(self): if hasattr(self, '_m_has_field_target_vehicle_i_ds'): return self._m_has_field_target_vehicle_i_ds self._m_has_field_target_vehicle_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_vehicle_i_ds', None) @property def has_field_skill_depot_id(self): if hasattr(self, '_m_has_field_skill_depot_id'): return self._m_has_field_skill_depot_id self._m_has_field_skill_depot_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_depot_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfConfigAiMixinSetBoolLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetBool(self._io, self, self._root)) class ConfigFootprint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_effect_pattern_name: self.default_effect_pattern_name = AuxTypes.String(self._io, self, self._root) if self.has_field_special_surfaces: self.special_surfaces = Output.DictOfEnumSceneSurfaceTypeDictOfEnumEFootprintPlatformConfigFootprintEffect(self._io, self, self._root) @property def has_field_default_effect_pattern_name(self): if hasattr(self, '_m_has_field_default_effect_pattern_name'): return self._m_has_field_default_effect_pattern_name self._m_has_field_default_effect_pattern_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_effect_pattern_name', None) @property def has_field_special_surfaces(self): if hasattr(self, '_m_has_field_special_surfaces'): return self._m_has_field_special_surfaces self._m_has_field_special_surfaces = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_special_surfaces', None) class DispConfigBattleFervorUpdateTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigBattleFervorUpdateTriggerByElementArt(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigBattleFervorUpdateTriggerByMonster(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBattleFervorUpateTriggerByTick(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigBattleFervorUpdateTriggerByAttackTag(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigBattleFervorUpdateTriggerByElementBurst(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBattleFervorUpdateTriggerByStateIdChanged(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivitySumoStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scheduld_id: self.scheduld_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_trial_avatar_pool: self.trial_avatar_pool = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_skill_pool: self.skill_pool = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_skill_pool: self.special_skill_pool = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_new_skill_vec: self.hint_new_skill_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_ranks: self.score_ranks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_monster_preview_vec: self.monster_preview_vec = Output.ArrayOfActivitySumoMonsterPreviewLengthS(self._io, self, self._root) if self.has_field_monster_wave_type: self.monster_wave_type = Output.EnumSumoStageMonsterWaveType(self._io, self, self._root) if self.has_field_primary_boss_monster_vec: self.primary_boss_monster_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_primary_normal_monster_vec: self.primary_normal_monster_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_monster_preview_vec(self): if hasattr(self, '_m_has_field_monster_preview_vec'): return self._m_has_field_monster_preview_vec self._m_has_field_monster_preview_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_monster_preview_vec', None) @property def has_field_primary_boss_monster_vec(self): if hasattr(self, '_m_has_field_primary_boss_monster_vec'): return self._m_has_field_primary_boss_monster_vec self._m_has_field_primary_boss_monster_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_primary_boss_monster_vec', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_score_ranks(self): if hasattr(self, '_m_has_field_score_ranks'): return self._m_has_field_score_ranks self._m_has_field_score_ranks = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_score_ranks', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_scheduld_id(self): if hasattr(self, '_m_has_field_scheduld_id'): return self._m_has_field_scheduld_id self._m_has_field_scheduld_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scheduld_id', None) @property def has_field_monster_wave_type(self): if hasattr(self, '_m_has_field_monster_wave_type'): return self._m_has_field_monster_wave_type self._m_has_field_monster_wave_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_monster_wave_type', None) @property def has_field_primary_normal_monster_vec(self): if hasattr(self, '_m_has_field_primary_normal_monster_vec'): return self._m_has_field_primary_normal_monster_vec self._m_has_field_primary_normal_monster_vec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_primary_normal_monster_vec', None) @property def has_field_skill_pool(self): if hasattr(self, '_m_has_field_skill_pool'): return self._m_has_field_skill_pool self._m_has_field_skill_pool = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_skill_pool', None) @property def has_field_hint_new_skill_vec(self): if hasattr(self, '_m_has_field_hint_new_skill_vec'): return self._m_has_field_hint_new_skill_vec self._m_has_field_hint_new_skill_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_hint_new_skill_vec', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_trial_avatar_pool(self): if hasattr(self, '_m_has_field_trial_avatar_pool'): return self._m_has_field_trial_avatar_pool self._m_has_field_trial_avatar_pool = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_trial_avatar_pool', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_special_skill_pool(self): if hasattr(self, '_m_has_field_special_skill_pool'): return self._m_has_field_special_skill_pool self._m_has_field_special_skill_pool = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_special_skill_pool', None) class ChannellerSlabDifficultyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetExtraAbilityState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state: self.state = Output.EnumExtraAbilityState(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class PriceTierConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableSprintInBlackMudMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfEnumMainPageUiDisableTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumMainPageUiDisableType(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeSConfigAiReturnToBornPosData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiReturnToBornPosData(self._io, self, self._root)) class AbilityFormulaComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LunaRiteQuestTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFishStockType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FishStockType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_range_min: self.range_min = self._io.read_f4le() if self.has_field_range_max: self.range_max = self._io.read_f4le() if self.has_field_rest_time_min: self.rest_time_min = self._io.read_f4le() if self.has_field_rest_time_max: self.rest_time_max = self._io.read_f4le() if self.has_field_facing_move_turn_interval: self.facing_move_turn_interval = self._io.read_f4le() if self.has_field_facing_move_min_avoidance_velecity: self.facing_move_min_avoidance_velecity = self._io.read_f4le() if self.has_field_obstacle_detect_range: self.obstacle_detect_range = self._io.read_f4le() if self.has_field_facing_move_weight: self.facing_move_weight = Output.ConfigAiFacingMoveWeight(self._io, self, self._root) @property def has_field_obstacle_detect_range(self): if hasattr(self, '_m_has_field_obstacle_detect_range'): return self._m_has_field_obstacle_detect_range self._m_has_field_obstacle_detect_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_obstacle_detect_range', None) @property def has_field_range_min(self): if hasattr(self, '_m_has_field_range_min'): return self._m_has_field_range_min self._m_has_field_range_min = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_range_min', None) @property def has_field_facing_move_min_avoidance_velecity(self): if hasattr(self, '_m_has_field_facing_move_min_avoidance_velecity'): return self._m_has_field_facing_move_min_avoidance_velecity self._m_has_field_facing_move_min_avoidance_velecity = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_facing_move_min_avoidance_velecity', None) @property def has_field_rest_time_max(self): if hasattr(self, '_m_has_field_rest_time_max'): return self._m_has_field_rest_time_max self._m_has_field_rest_time_max = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_rest_time_max', None) @property def has_field_facing_move_turn_interval(self): if hasattr(self, '_m_has_field_facing_move_turn_interval'): return self._m_has_field_facing_move_turn_interval self._m_has_field_facing_move_turn_interval = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_facing_move_turn_interval', None) @property def has_field_rest_time_min(self): if hasattr(self, '_m_has_field_rest_time_min'): return self._m_has_field_rest_time_min self._m_has_field_rest_time_min = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_rest_time_min', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_range_max(self): if hasattr(self, '_m_has_field_range_max'): return self._m_has_field_range_max self._m_has_field_range_max = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_range_max', None) @property def has_field_facing_move_weight(self): if hasattr(self, '_m_has_field_facing_move_weight'): return self._m_has_field_facing_move_weight self._m_has_field_facing_move_weight = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_facing_move_weight', None) class EnumAbilityFormula(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityFormula, self.data.value) return getattr(self, '_m_value', None) class ConfigWidgetBonfire(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_combat_destroy_distance: self.combat_destroy_distance = self._io.read_f4le() @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def has_field_combat_destroy_distance(self): if hasattr(self, '_m_has_field_combat_destroy_distance'): return self._m_has_field_combat_destroy_distance self._m_has_field_combat_destroy_distance = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_combat_destroy_distance', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class EnumLuaCallType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LuaCallType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigLogoPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigLogoPage(self._io, self, self._root)) class BounceConjuringPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_stay_time: self.activity_stay_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_watcher_id: self.quest_watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_id: self.match_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_match_id(self): if hasattr(self, '_m_has_field_match_id'): return self._m_has_field_match_id self._m_has_field_match_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_match_id', None) @property def has_field_activity_stay_time(self): if hasattr(self, '_m_has_field_activity_stay_time'): return self._m_has_field_activity_stay_time self._m_has_field_activity_stay_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_stay_time', None) @property def has_field_quest_watcher_id(self): if hasattr(self, '_m_has_field_quest_watcher_id'): return self._m_has_field_quest_watcher_id self._m_has_field_quest_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_watcher_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class EnumSelectTargetsSortType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SelectTargetsSortType, self.data.value) return getattr(self, '_m_value', None) class EnumSectrStreamObjectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrStreamObjectType, self.data.value) return getattr(self, '_m_value', None) class EnumRemoveActorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RemoveActorType, self.data.value) return getattr(self, '_m_value', None) class ConfigBattleFervorUpateTriggerByTick(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class BlockLimit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_block_id: self.block_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_block_id(self): if hasattr(self, '_m_has_field_block_id'): return self._m_has_field_block_id self._m_has_field_block_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_block_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_count', None) class MechanicusCardCurseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRogueDiaryBuffType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueDiaryBuffType, self.data.value) return getattr(self, '_m_value', None) class ServerMessageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementDefine(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumLightLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LightLevel, self.data.value) return getattr(self, '_m_value', None) class ConfigBeHitBlendShake(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioSettingSliderPostVoice(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.AudioSettingSlider(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_change_voice_array: self.change_voice_array = Output.ArrayOfAudioSettingSliderPostVoiceItemLengthU(self._io, self, self._root) @property def rtpc(self): if hasattr(self, '_m_rtpc'): return self._m_rtpc self._m_rtpc = self.base.rtpc return getattr(self, '_m_rtpc', None) @property def min_value(self): if hasattr(self, '_m_min_value'): return self._m_min_value self._m_min_value = self.base.min_value return getattr(self, '_m_min_value', None) @property def each_values(self): if hasattr(self, '_m_each_values'): return self._m_each_values self._m_each_values = self.base.each_values return getattr(self, '_m_each_values', None) @property def max_value(self): if hasattr(self, '_m_max_value'): return self._m_max_value self._m_max_value = self.base.max_value return getattr(self, '_m_max_value', None) @property def has_field_change_voice_array(self): if hasattr(self, '_m_has_field_change_voice_array'): return self._m_has_field_change_voice_array self._m_has_field_change_voice_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_change_voice_array', None) @property def text_map(self): if hasattr(self, '_m_text_map'): return self._m_text_map self._m_text_map = self.base.text_map return getattr(self, '_m_text_map', None) class SpeicalFurnitureTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiBrownianMotionSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiBrownianMotionData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiBrownianMotionData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigMusicDoubleNoLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class GuidePaimonDisappearEnd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumSceneVehicleSummonPointMapMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneVehicleSummonPointMapMarkType, self.data.value) return getattr(self, '_m_value', None) class ByHitBoxType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_box_type: self.hit_box_type = Output.EnumHitBoxType(self._io, self, self._root) @property def has_field_hit_box_type(self): if hasattr(self, '_m_has_field_hit_box_type'): return self._m_has_field_hit_box_type self._m_has_field_hit_box_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_box_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigSceneHomeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_arrangement_info_list: self.block_arrangement_info_list = Output.ArrayOfConfigHomeBlockLengthU(self._io, self, self._root) if self.has_field_is_set_born_pos: self.is_set_born_pos = self._io.read_u1() if self.has_field_born_pos: self.born_pos = Output.Vector(self._io, self, self._root) if self.has_field_born_rot: self.born_rot = Output.Vector(self._io, self, self._root) if self.has_field_door_list: self.door_list = Output.ArrayOfConfigHomeFurnitureLengthU(self._io, self, self._root) if self.has_field_stair_list: self.stair_list = Output.ArrayOfConfigHomeFurnitureLengthU(self._io, self, self._root) if self.has_field_main_house: self.main_house = Output.ConfigHomeFurniture(self._io, self, self._root) if self.has_field_djinn_pos: self.djinn_pos = Output.Vector(self._io, self, self._root) if self.has_field_tmp_version: self.tmp_version = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_block_arrangement_info_list(self): if hasattr(self, '_m_has_field_block_arrangement_info_list'): return self._m_has_field_block_arrangement_info_list self._m_has_field_block_arrangement_info_list = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_block_arrangement_info_list', None) @property def has_field_door_list(self): if hasattr(self, '_m_has_field_door_list'): return self._m_has_field_door_list self._m_has_field_door_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_door_list', None) @property def has_field_djinn_pos(self): if hasattr(self, '_m_has_field_djinn_pos'): return self._m_has_field_djinn_pos self._m_has_field_djinn_pos = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_djinn_pos', None) @property def has_field_stair_list(self): if hasattr(self, '_m_has_field_stair_list'): return self._m_has_field_stair_list self._m_has_field_stair_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_stair_list', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_born_rot(self): if hasattr(self, '_m_has_field_born_rot'): return self._m_has_field_born_rot self._m_has_field_born_rot = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_born_rot', None) @property def has_field_main_house(self): if hasattr(self, '_m_has_field_main_house'): return self._m_has_field_main_house self._m_has_field_main_house = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_main_house', None) @property def has_field_is_set_born_pos(self): if hasattr(self, '_m_has_field_is_set_born_pos'): return self._m_has_field_is_set_born_pos self._m_has_field_is_set_born_pos = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_is_set_born_pos', None) @property def has_field_born_pos(self): if hasattr(self, '_m_has_field_born_pos'): return self._m_has_field_born_pos self._m_has_field_born_pos = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_born_pos', None) @property def has_field_tmp_version(self): if hasattr(self, '_m_has_field_tmp_version'): return self._m_has_field_tmp_version self._m_has_field_tmp_version = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_tmp_version', None) class OfferingMaxLevelLimitTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachModifierByNeuronMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_neuron_name_list: self.neuron_name_list = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) if self.has_field_remove_operator: self.remove_operator = Output.EnumNeuronMixinRemoveOperatorType(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_authority_only: self.authority_only = self._io.read_u1() @property def has_field_authority_only(self): if hasattr(self, '_m_has_field_authority_only'): return self._m_has_field_authority_only self._m_has_field_authority_only = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_authority_only', None) @property def has_field_remove_operator(self): if hasattr(self, '_m_has_field_remove_operator'): return self._m_has_field_remove_operator self._m_has_field_remove_operator = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_remove_operator', None) @property def has_field_neuron_name_list(self): if hasattr(self, '_m_has_field_neuron_name_list'): return self._m_has_field_neuron_name_list self._m_has_field_neuron_name_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_neuron_name_list', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfFishBaitFeatureLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FishBaitFeature(self._io, self, self._root)) class ActivityAbilityGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_combat_destroy: self.is_combat_destroy = self._io.read_u1() if self.has_field_combat_destroy_distance: self.combat_destroy_distance = self._io.read_f4le() if self.has_field_is_distance_destroy: self.is_distance_destroy = self._io.read_u1() if self.has_field_distance_destroy_distance: self.distance_destroy_distance = self._io.read_f4le() if self.has_field_is_has_collision: self.is_has_collision = self._io.read_u1() if self.has_field_collision_include_npc: self.collision_include_npc = self._io.read_u1() if self.has_field_collision_include_water: self.collision_include_water = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_create_height: self.create_height = self._io.read_f4le() if self.has_field_create_rot: self.create_rot = Output.Vector(self._io, self, self._root) if self.has_field_is_leave_scene_destroy: self.is_leave_scene_destroy = self._io.read_u1() @property def has_field_distance_destroy_distance(self): if hasattr(self, '_m_has_field_distance_destroy_distance'): return self._m_has_field_distance_destroy_distance self._m_has_field_distance_destroy_distance = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_distance_destroy_distance', None) @property def has_field_is_leave_scene_destroy(self): if hasattr(self, '_m_has_field_is_leave_scene_destroy'): return self._m_has_field_is_leave_scene_destroy self._m_has_field_is_leave_scene_destroy = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_is_leave_scene_destroy', None) @property def has_field_is_distance_destroy(self): if hasattr(self, '_m_has_field_is_distance_destroy'): return self._m_has_field_is_distance_destroy self._m_has_field_is_distance_destroy = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_is_distance_destroy', None) @property def has_field_collision_include_water(self): if hasattr(self, '_m_has_field_collision_include_water'): return self._m_has_field_collision_include_water self._m_has_field_collision_include_water = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_collision_include_water', None) @property def has_field_create_rot(self): if hasattr(self, '_m_has_field_create_rot'): return self._m_has_field_create_rot self._m_has_field_create_rot = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_create_rot', None) @property def has_field_collision_include_npc(self): if hasattr(self, '_m_has_field_collision_include_npc'): return self._m_has_field_collision_include_npc self._m_has_field_collision_include_npc = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_collision_include_npc', None) @property def has_field_create_height(self): if hasattr(self, '_m_has_field_create_height'): return self._m_has_field_create_height self._m_has_field_create_height = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_create_height', None) @property def has_field_is_combat_destroy(self): if hasattr(self, '_m_has_field_is_combat_destroy'): return self._m_has_field_is_combat_destroy self._m_has_field_is_combat_destroy = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_is_combat_destroy', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_combat_destroy_distance(self): if hasattr(self, '_m_has_field_combat_destroy_distance'): return self._m_has_field_combat_destroy_distance self._m_has_field_combat_destroy_distance = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_combat_destroy_distance', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def has_field_is_has_collision(self): if hasattr(self, '_m_has_field_is_has_collision'): return self._m_has_field_is_has_collision self._m_has_field_is_has_collision = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_is_has_collision', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class FlightActivityDayExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pos', None) class ConfigMusicDoubleNoGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class EnumReminderShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReminderShowType, self.data.value) return getattr(self, '_m_value', None) class ConfigPerfNumberItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_device_spec_item: self.device_spec_item = Output.DictOfAuxTypesStringF4(self._io, self, self._root) if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfNumberItemOptionArrayInfo(self._io, self, self._root) if self.has_field_override_map: self.override_map = Output.DictOfAuxTypesStringConfigPerfNumberItemOverrideInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def has_field_override_map(self): if hasattr(self, '_m_has_field_override_map'): return self._m_has_field_override_map self._m_has_field_override_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map', None) @property def has_field_device_spec_item(self): if hasattr(self, '_m_has_field_device_spec_item'): return self._m_has_field_device_spec_item self._m_has_field_device_spec_item = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_device_spec_item', None) class SphereDetectDirectionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class Point2d(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_x: self.x = self._io.read_f4le() if self.has_field_y: self.y = self._io.read_f4le() @property def has_field_x(self): if hasattr(self, '_m_has_field_x'): return self._m_has_field_x self._m_has_field_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_x', None) @property def has_field_y(self): if hasattr(self, '_m_has_field_y'): return self._m_has_field_y self._m_has_field_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y', None) class ConfigSpeechBubbleAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hold_on: self.hold_on = self._io.read_u1() if self.has_field_try_stop: self.try_stop = self._io.read_u1() @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_priority', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_hold_on(self): if hasattr(self, '_m_has_field_hold_on'): return self._m_has_field_hold_on self._m_has_field_hold_on = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_hold_on', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_try_stop(self): if hasattr(self, '_m_has_field_try_stop'): return self._m_has_field_try_stop self._m_has_field_try_stop = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_try_stop', None) class EnumRegionalPlayVarType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionalPlayVarType, self.data.value) return getattr(self, '_m_value', None) class CustomLevelComponentConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_component_id: self.component_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_name: self.component_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_desc: self.tag_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_icon_hash: self.component_icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_icon_hash: self.component_icon_hash_pre = self._io.read_s1() if self.has_field_brick_name: self.brick_name = AuxTypes.String(self._io, self, self._root) if self.has_field_deploy_gadget_id: self.deploy_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_gadget_id: self.server_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_level: self.config_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate_type: self.rotate_type = Output.EnumBrickRotateType(self._io, self, self._root) if self.has_field_component_cost: self.component_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_deploy_count: self.max_deploy_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hand_book_id: self.hand_book_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_visable: self.is_visable = self._io.read_u1() if self.has_field_brick_type: self.brick_type = Output.EnumBrickType(self._io, self, self._root) if self.has_field_can_copy: self.can_copy = self._io.read_u1() if self.has_field_component_desc: self.component_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_size: self.component_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_deploy: self.component_deploy = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_component_cost(self): if hasattr(self, '_m_has_field_component_cost'): return self._m_has_field_component_cost self._m_has_field_component_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_component_cost', None) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_is_visable(self): if hasattr(self, '_m_has_field_is_visable'): return self._m_has_field_is_visable self._m_has_field_is_visable = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_is_visable', None) @property def has_field_brick_name(self): if hasattr(self, '_m_has_field_brick_name'): return self._m_has_field_brick_name self._m_has_field_brick_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_brick_name', None) @property def has_field_config_level(self): if hasattr(self, '_m_has_field_config_level'): return self._m_has_field_config_level self._m_has_field_config_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_config_level', None) @property def has_field_brick_type(self): if hasattr(self, '_m_has_field_brick_type'): return self._m_has_field_brick_type self._m_has_field_brick_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_brick_type', None) @property def has_field_max_deploy_count(self): if hasattr(self, '_m_has_field_max_deploy_count'): return self._m_has_field_max_deploy_count self._m_has_field_max_deploy_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_max_deploy_count', None) @property def has_field_hand_book_id(self): if hasattr(self, '_m_has_field_hand_book_id'): return self._m_has_field_hand_book_id self._m_has_field_hand_book_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_hand_book_id', None) @property def has_field_component_id(self): if hasattr(self, '_m_has_field_component_id'): return self._m_has_field_component_id self._m_has_field_component_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_component_id', None) @property def has_field_component_deploy(self): if hasattr(self, '_m_has_field_component_deploy'): return self._m_has_field_component_deploy self._m_has_field_component_deploy = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_component_deploy', None) @property def has_field_component_name(self): if hasattr(self, '_m_has_field_component_name'): return self._m_has_field_component_name self._m_has_field_component_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_component_name', None) @property def has_field_component_desc(self): if hasattr(self, '_m_has_field_component_desc'): return self._m_has_field_component_desc self._m_has_field_component_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_component_desc', None) @property def has_field_deploy_gadget_id(self): if hasattr(self, '_m_has_field_deploy_gadget_id'): return self._m_has_field_deploy_gadget_id self._m_has_field_deploy_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_deploy_gadget_id', None) @property def has_field_component_icon_hash(self): if hasattr(self, '_m_has_field_component_icon_hash'): return self._m_has_field_component_icon_hash self._m_has_field_component_icon_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_component_icon_hash', None) @property def has_field_component_size(self): if hasattr(self, '_m_has_field_component_size'): return self._m_has_field_component_size self._m_has_field_component_size = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_component_size', None) @property def has_field_tag_desc(self): if hasattr(self, '_m_has_field_tag_desc'): return self._m_has_field_tag_desc self._m_has_field_tag_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tag_desc', None) @property def has_field_can_copy(self): if hasattr(self, '_m_has_field_can_copy'): return self._m_has_field_can_copy self._m_has_field_can_copy = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_can_copy', None) @property def has_field_server_gadget_id(self): if hasattr(self, '_m_has_field_server_gadget_id'): return self._m_has_field_server_gadget_id self._m_has_field_server_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_server_gadget_id', None) @property def has_field_rotate_type(self): if hasattr(self, '_m_has_field_rotate_type'): return self._m_has_field_rotate_type self._m_has_field_rotate_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_rotate_type', None) class GuideTriggerExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigTrailData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class Int16NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class EnumTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetType, self.data.value) return getattr(self, '_m_value', None) class ConfigAudioMapInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_area_state_key: self.area_state_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_areas: self.areas = Output.ArrayOfConfigAudioMapAreaLengthU(self._io, self, self._root) @property def has_field_area_state_key(self): if hasattr(self, '_m_has_field_area_state_key'): return self._m_has_field_area_state_key self._m_has_field_area_state_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_state_key', None) @property def has_field_areas(self): if hasattr(self, '_m_has_field_areas'): return self._m_has_field_areas self._m_has_field_areas = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_areas', None) class ByHasModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ProductPs4packageDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMonster(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCharacter(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_initial_poses: self.initial_poses = Output.DictOfAuxTypesStringConfigMonsterInitialPose(self._io, self, self._root) if self.has_field_aibeta: self.aibeta = Output.ConfigAiBeta(self._io, self, self._root) if self.has_field_input_keys: self.input_keys = Output.ArrayOfConfigKeyInputLengthU(self._io, self, self._root) if self.has_field_move: self.move = Output.DispConfigMove(self._io, self, self._root) if self.has_field_audio: self.audio = Output.ConfigMonsterAudio(self._io, self, self._root) if self.has_field_emoji_bubble: self.emoji_bubble = Output.ConfigEmojiBubble(self._io, self, self._root) if self.has_field_character_rendering: self.character_rendering = Output.ConfigCharacterRendering(self._io, self, self._root) if self.has_field_animal: self.animal = Output.ConfigAnimal(self._io, self, self._root) if self.has_field_field: self.field = Output.ConfigTrigger(self._io, self, self._root) if self.has_field_capture_group: self.capture_group = Output.ConfigCaptureGroup(self._io, self, self._root) if self.has_field_camera_adjust_map: self.camera_adjust_map = Output.DictOfAuxTypesStringDispConfigSpecialCamera(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def bind_emotions(self): if hasattr(self, '_m_bind_emotions'): return self._m_bind_emotions self._m_bind_emotions = self.base.bind_emotions return getattr(self, '_m_bind_emotions', None) @property def has_field_input_keys(self): if hasattr(self, '_m_has_field_input_keys'): return self._m_has_field_input_keys self._m_has_field_input_keys = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_input_keys', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def billboard(self): if hasattr(self, '_m_billboard'): return self._m_billboard self._m_billboard = self.base.billboard return getattr(self, '_m_billboard', None) @property def has_field_field(self): if hasattr(self, '_m_has_field_field'): return self._m_has_field_field self._m_has_field_field = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_field', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_audio', None) @property def equip_controller(self): if hasattr(self, '_m_equip_controller'): return self._m_equip_controller self._m_equip_controller = self.base.equip_controller return getattr(self, '_m_equip_controller', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def sub_equip_controllers(self): if hasattr(self, '_m_sub_equip_controllers'): return self._m_sub_equip_controllers self._m_sub_equip_controllers = self.base.sub_equip_controllers return getattr(self, '_m_sub_equip_controllers', None) @property def abilities(self): if hasattr(self, '_m_abilities'): return self._m_abilities self._m_abilities = self.base.abilities return getattr(self, '_m_abilities', None) @property def has_field_animal(self): if hasattr(self, '_m_has_field_animal'): return self._m_has_field_animal self._m_has_field_animal = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_animal', None) @property def has_field_initial_poses(self): if hasattr(self, '_m_has_field_initial_poses'): return self._m_has_field_initial_poses self._m_has_field_initial_poses = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_initial_poses', None) @property def has_field_move(self): if hasattr(self, '_m_has_field_move'): return self._m_has_field_move self._m_has_field_move = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_move', None) @property def has_field_emoji_bubble(self): if hasattr(self, '_m_has_field_emoji_bubble'): return self._m_has_field_emoji_bubble self._m_has_field_emoji_bubble = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_emoji_bubble', None) @property def has_field_aibeta(self): if hasattr(self, '_m_has_field_aibeta'): return self._m_has_field_aibeta self._m_has_field_aibeta = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_aibeta', None) @property def face(self): if hasattr(self, '_m_face'): return self._m_face self._m_face = self.base.face return getattr(self, '_m_face', None) @property def has_field_capture_group(self): if hasattr(self, '_m_has_field_capture_group'): return self._m_has_field_capture_group self._m_has_field_capture_group = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_capture_group', None) @property def part_control(self): if hasattr(self, '_m_part_control'): return self._m_part_control self._m_part_control = self.base.part_control return getattr(self, '_m_part_control', None) @property def combat(self): if hasattr(self, '_m_combat'): return self._m_combat self._m_combat = self.base.combat return getattr(self, '_m_combat', None) @property def has_field_camera_adjust_map(self): if hasattr(self, '_m_has_field_camera_adjust_map'): return self._m_has_field_camera_adjust_map self._m_has_field_camera_adjust_map = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_camera_adjust_map', None) @property def has_field_character_rendering(self): if hasattr(self, '_m_has_field_character_rendering'): return self._m_has_field_character_rendering self._m_has_field_character_rendering = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_character_rendering', None) @property def state_layers(self): if hasattr(self, '_m_state_layers'): return self._m_state_layers self._m_state_layers = self.base.state_layers return getattr(self, '_m_state_layers', None) class ConfigAudioSurfaceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_switch_key: self.switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_tall_grass_rtpc_id: self.tall_grass_rtpc_id = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_water_depth_rtpc_id: self.water_depth_rtpc_id = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_switch_map: self.switch_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_rtpc_map: self.rtpc_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_water_depth_rtpc_id(self): if hasattr(self, '_m_has_field_water_depth_rtpc_id'): return self._m_has_field_water_depth_rtpc_id self._m_has_field_water_depth_rtpc_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_water_depth_rtpc_id', None) @property def has_field_rtpc_map(self): if hasattr(self, '_m_has_field_rtpc_map'): return self._m_has_field_rtpc_map self._m_has_field_rtpc_map = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_rtpc_map', None) @property def has_field_switch_map(self): if hasattr(self, '_m_has_field_switch_map'): return self._m_has_field_switch_map self._m_has_field_switch_map = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_switch_map', None) @property def has_field_tall_grass_rtpc_id(self): if hasattr(self, '_m_has_field_tall_grass_rtpc_id'): return self._m_has_field_tall_grass_rtpc_id self._m_has_field_tall_grass_rtpc_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tall_grass_rtpc_id', None) @property def has_field_switch_key(self): if hasattr(self, '_m_has_field_switch_key'): return self._m_has_field_switch_key self._m_has_field_switch_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_switch_key', None) class ProudSkillList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfF4LengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(self._io.read_f4le()) class QuestCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_parent_quest_id: self.parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_parent_quest_id(self): if hasattr(self, '_m_has_field_parent_quest_id'): return self._m_has_field_parent_quest_id self._m_has_field_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_parent_quest_id', None) class ConfigSimpleMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_const_speed_ratio: self.const_speed_ratio = self._io.read_f4le() if self.has_field_follow_reference_system: self.follow_reference_system = self._io.read_u1() @property def has_field_const_speed_ratio(self): if hasattr(self, '_m_has_field_const_speed_ratio'): return self._m_has_field_const_speed_ratio self._m_has_field_const_speed_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_const_speed_ratio', None) @property def has_field_follow_reference_system(self): if hasattr(self, '_m_has_field_follow_reference_system'): return self._m_has_field_follow_reference_system self._m_has_field_follow_reference_system = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_follow_reference_system', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class IrodoriChessCardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityIslandPartyOverallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_display_countdown: self.card_display_countdown = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_display_countdown: self.score_display_countdown = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_card_display_countdown(self): if hasattr(self, '_m_has_field_card_display_countdown'): return self._m_has_field_card_display_countdown self._m_has_field_card_display_countdown = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_card_display_countdown', None) @property def has_field_score_display_countdown(self): if hasattr(self, '_m_has_field_score_display_countdown'): return self._m_has_field_score_display_countdown self._m_has_field_score_display_countdown = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score_display_countdown', None) class RoguelikeShikigamiExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sequence_id: self.sequence_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_cond: self.unlock_cond = Output.ArrayOfRoguelikeShikigamiUnlockConfigLengthS(self._io, self, self._root) if self.has_field_cost_item_id: self.cost_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_item_count: self.cost_item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shiki_skill_name: self.shiki_skill_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shiki_skill_desc: self.shiki_skill_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_shiki_skill_desc(self): if hasattr(self, '_m_has_field_shiki_skill_desc'): return self._m_has_field_shiki_skill_desc self._m_has_field_shiki_skill_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_shiki_skill_desc', None) @property def has_field_shiki_skill_name(self): if hasattr(self, '_m_has_field_shiki_skill_name'): return self._m_has_field_shiki_skill_name self._m_has_field_shiki_skill_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_shiki_skill_name', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_cost_item_id(self): if hasattr(self, '_m_has_field_cost_item_id'): return self._m_has_field_cost_item_id self._m_has_field_cost_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cost_item_id', None) @property def has_field_cost_item_count(self): if hasattr(self, '_m_has_field_cost_item_count'): return self._m_has_field_cost_item_count self._m_has_field_cost_item_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cost_item_count', None) @property def has_field_unlock_cond(self): if hasattr(self, '_m_has_field_unlock_cond'): return self._m_has_field_unlock_cond self._m_has_field_unlock_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_cond', None) @property def has_field_sequence_id(self): if hasattr(self, '_m_has_field_sequence_id'): return self._m_has_field_sequence_id self._m_has_field_sequence_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sequence_id', None) class ShopRotateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate_id: self.rotate_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate_order: self.rotate_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_rotate_id(self): if hasattr(self, '_m_has_field_rotate_id'): return self._m_has_field_rotate_id self._m_has_field_rotate_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_rotate_id', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_rotate_order(self): if hasattr(self, '_m_has_field_rotate_order'): return self._m_has_field_rotate_order self._m_has_field_rotate_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_rotate_order', None) class ShowProgressBarAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_show: self.show = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumQuestGuideStyle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestGuideStyle, self.data.value) return getattr(self, '_m_value', None) class FrameFaceAnimationPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OverflowTransformExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_transform_type: self.transform_type = Output.EnumOverflowTransformType(self._io, self, self._root) if self.has_field_transform_id: self.transform_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_transform_base_count: self.transform_base_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_transform_results: self.transform_results = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_transform_item_limit_type: self.transform_item_limit_type = Output.EnumItemLimitType(self._io, self, self._root) @property def has_field_transform_id(self): if hasattr(self, '_m_has_field_transform_id'): return self._m_has_field_transform_id self._m_has_field_transform_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_transform_id', None) @property def has_field_transform_item_limit_type(self): if hasattr(self, '_m_has_field_transform_item_limit_type'): return self._m_has_field_transform_item_limit_type self._m_has_field_transform_item_limit_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_transform_item_limit_type', None) @property def has_field_transform_type(self): if hasattr(self, '_m_has_field_transform_type'): return self._m_has_field_transform_type self._m_has_field_transform_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_transform_type', None) @property def has_field_transform_results(self): if hasattr(self, '_m_has_field_transform_results'): return self._m_has_field_transform_results self._m_has_field_transform_results = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_transform_results', None) @property def has_field_transform_base_count(self): if hasattr(self, '_m_has_field_transform_base_count'): return self._m_has_field_transform_base_count self._m_has_field_transform_base_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_transform_base_count', None) class FireEffectFirework(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_scale: self.scale = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class EnumTypeCount(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TypeCount, self.data.value) return getattr(self, '_m_value', None) class FireChargeBarEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ByHasShield(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumHasShieldType(self._io, self, self._root) if self.has_field_use_potent_shield: self.use_potent_shield = self._io.read_u1() if self.has_field_potent_shield_type: self.potent_shield_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_use_potent_shield(self): if hasattr(self, '_m_has_field_use_potent_shield'): return self._m_has_field_use_potent_shield self._m_has_field_use_potent_shield = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_potent_shield', None) @property def has_field_potent_shield_type(self): if hasattr(self, '_m_has_field_potent_shield_type'): return self._m_has_field_potent_shield_type self._m_has_field_potent_shield_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_potent_shield_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumParticleEmitLevelType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ParticleEmitLevelType, self.data.value) return getattr(self, '_m_value', None) class BlossomRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward: self.preview_reward = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_preview_reward(self): if hasattr(self, '_m_has_field_preview_reward'): return self._m_has_field_preview_reward self._m_has_field_preview_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_preview_reward', None) class ActionPointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SceneTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterLittleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCameraSplineCatmullTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBaseTarget(self._io, self, self._root) @property def position(self): if hasattr(self, '_m_position'): return self._m_position self._m_position = self.base.position return getattr(self, '_m_position', None) @property def length_ratio(self): if hasattr(self, '_m_length_ratio'): return self._m_length_ratio self._m_length_ratio = self.base.length_ratio return getattr(self, '_m_length_ratio', None) @property def s_list(self): if hasattr(self, '_m_s_list'): return self._m_s_list self._m_s_list = self.base.s_list return getattr(self, '_m_s_list', None) @property def t_list(self): if hasattr(self, '_m_t_list'): return self._m_t_list self._m_t_list = self.base.t_list return getattr(self, '_m_t_list', None) class DictOfEnumVolatileTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumVolatileTypeAuxTypesVlqBase128LeS(self._io, self, self._root)) class ConfigPoseInitialParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_int_params: self.int_params = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_float_params: self.float_params = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_bool_params: self.bool_params = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_int_params(self): if hasattr(self, '_m_has_field_int_params'): return self._m_has_field_int_params self._m_has_field_int_params = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_params', None) @property def has_field_float_params(self): if hasattr(self, '_m_has_field_float_params'): return self._m_has_field_float_params self._m_has_field_float_params = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_float_params', None) @property def has_field_bool_params(self): if hasattr(self, '_m_has_field_bool_params'): return self._m_has_field_bool_params self._m_has_field_bool_params = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_bool_params', None) class ProductPsnCompensationDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_content_vec: self.content_vec = Output.ArrayOfPackageContentConfigLengthS(self._io, self, self._root) if self.has_field_mail_config_id: self.mail_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_count: self.limit_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_content_vec(self): if hasattr(self, '_m_has_field_content_vec'): return self._m_has_field_content_vec self._m_has_field_content_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_content_vec', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_mail_config_id(self): if hasattr(self, '_m_has_field_mail_config_id'): return self._m_has_field_mail_config_id self._m_has_field_mail_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mail_config_id', None) @property def has_field_limit_count(self): if hasattr(self, '_m_has_field_limit_count'): return self._m_has_field_limit_count self._m_has_field_limit_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_limit_count', None) class ConfigGraphicsRequirement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_info: self.info = AuxTypes.String(self._io, self, self._root) if self.has_field_values: self.values = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_info(self): if hasattr(self, '_m_has_field_info'): return self._m_has_field_info self._m_has_field_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_info', None) @property def has_field_values(self): if hasattr(self, '_m_has_field_values'): return self._m_has_field_values self._m_has_field_values = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_values', None) class FireSubEmitterEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_scale: self.scale = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class EnumCaptureCodexShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CaptureCodexShowType, self.data.value) return getattr(self, '_m_value', None) class NativeHelper(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLcBaseInteeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_dic: self.config_dic = Output.DictOfAuxTypesStringDispConfigLcBaseIntee(self._io, self, self._root) @property def has_field_config_dic(self): if hasattr(self, '_m_has_field_config_dic'): return self._m_has_field_config_dic self._m_has_field_config_dic = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_dic', None) class ArrayOfGadgetInteractActionConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.GadgetInteractActionConfig(self._io, self, self._root)) class FindHilichurlAssignmentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DummyAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_list: self.action_list = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_list', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigActionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_local_id: self.local_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumActionPointType(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) if self.has_field_capacity: self.capacity = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_act_zone_inner_radius: self.act_zone_inner_radius = self._io.read_f4le() if self.has_field_act_zone_outer_radius: self.act_zone_outer_radius = self._io.read_f4le() if self.has_field_freestyle: self.freestyle = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_face_center: self.face_center = self._io.read_u1() @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_rot', None) @property def has_field_capacity(self): if hasattr(self, '_m_has_field_capacity'): return self._m_has_field_capacity self._m_has_field_capacity = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_capacity', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_local_id(self): if hasattr(self, '_m_has_field_local_id'): return self._m_has_field_local_id self._m_has_field_local_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_local_id', None) @property def has_field_face_center(self): if hasattr(self, '_m_has_field_face_center'): return self._m_has_field_face_center self._m_has_field_face_center = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_face_center', None) @property def has_field_freestyle(self): if hasattr(self, '_m_has_field_freestyle'): return self._m_has_field_freestyle self._m_has_field_freestyle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_freestyle', None) @property def has_field_act_zone_inner_radius(self): if hasattr(self, '_m_has_field_act_zone_inner_radius'): return self._m_has_field_act_zone_inner_radius self._m_has_field_act_zone_inner_radius = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_act_zone_inner_radius', None) @property def has_field_act_zone_outer_radius(self): if hasattr(self, '_m_has_field_act_zone_outer_radius'): return self._m_has_field_act_zone_outer_radius self._m_has_field_act_zone_outer_radius = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_act_zone_outer_radius', None) class BonusActivityStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigQteStepBaseCondLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigQteStepBaseCond(self._io, self, self._root)) class SetEmissionScaler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_material_type: self.material_type = Output.EnumBodyMaterialType(self._io, self, self._root) if self.has_field_use_default_color: self.use_default_color = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_emission_power: self.emission_power = self._io.read_f4le() if self.has_field_emission_color: self.emission_color = Output.ColorVector(self._io, self, self._root) @property def has_field_material_type(self): if hasattr(self, '_m_has_field_material_type'): return self._m_has_field_material_type self._m_has_field_material_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_material_type', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_emission_color(self): if hasattr(self, '_m_has_field_emission_color'): return self._m_has_field_emission_color self._m_has_field_emission_color = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_emission_color', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_emission_power(self): if hasattr(self, '_m_has_field_emission_power'): return self._m_has_field_emission_power self._m_has_field_emission_power = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_emission_power', None) @property def has_field_use_default_color(self): if hasattr(self, '_m_has_field_use_default_color'): return self._m_has_field_use_default_color self._m_has_field_use_default_color = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_default_color', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ReliquarySetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AnimatorParamType2comparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProjectionGameGuideFinishTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfStringKeyItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class ConfigEntityReuseData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_reuse_list: self.entity_reuse_list = Output.ArrayOfConfigEntityReuseLengthU(self._io, self, self._root) @property def has_field_entity_reuse_list(self): if hasattr(self, '_m_has_field_entity_reuse_list'): return self._m_has_field_entity_reuse_list self._m_has_field_entity_reuse_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_reuse_list', None) class ChessCardNumericalModificationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RotType, self.data.value) return getattr(self, '_m_value', None) class CutsceneTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfNewActivityCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.NewActivityCond(self._io, self, self._root)) class EnumCodexQuestItemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CodexQuestItemType, self.data.value) return getattr(self, '_m_value', None) class MichiaeOverallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_offering_id: self.offering_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_statue_group_id: self.statue_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_statue_config_id: self.statue_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_watcher_list: self.boss_watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_statue_cd: self.statue_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pray_effect_range: self.pray_effect_range = self._io.read_f4le() if self.has_field_dark_challenge_reward_range: self.dark_challenge_reward_range = self._io.read_f4le() if self.has_field_activity_scene_id: self.activity_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_challenge_reward_range: self.boss_challenge_reward_range = self._io.read_f4le() if self.has_field_crystal_exp_material_id: self.crystal_exp_material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radar_open_level: self.radar_open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_all_radar_open_level: self.all_radar_open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dark_challenge_reward_range(self): if hasattr(self, '_m_has_field_dark_challenge_reward_range'): return self._m_has_field_dark_challenge_reward_range self._m_has_field_dark_challenge_reward_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_dark_challenge_reward_range', None) @property def has_field_boss_watcher_list(self): if hasattr(self, '_m_has_field_boss_watcher_list'): return self._m_has_field_boss_watcher_list self._m_has_field_boss_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_boss_watcher_list', None) @property def has_field_activity_scene_id(self): if hasattr(self, '_m_has_field_activity_scene_id'): return self._m_has_field_activity_scene_id self._m_has_field_activity_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_activity_scene_id', None) @property def has_field_offering_id(self): if hasattr(self, '_m_has_field_offering_id'): return self._m_has_field_offering_id self._m_has_field_offering_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_offering_id', None) @property def has_field_radar_open_level(self): if hasattr(self, '_m_has_field_radar_open_level'): return self._m_has_field_radar_open_level self._m_has_field_radar_open_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_radar_open_level', None) @property def has_field_pray_effect_range(self): if hasattr(self, '_m_has_field_pray_effect_range'): return self._m_has_field_pray_effect_range self._m_has_field_pray_effect_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pray_effect_range', None) @property def has_field_statue_config_id(self): if hasattr(self, '_m_has_field_statue_config_id'): return self._m_has_field_statue_config_id self._m_has_field_statue_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_statue_config_id', None) @property def has_field_statue_cd(self): if hasattr(self, '_m_has_field_statue_cd'): return self._m_has_field_statue_cd self._m_has_field_statue_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_statue_cd', None) @property def has_field_crystal_exp_material_id(self): if hasattr(self, '_m_has_field_crystal_exp_material_id'): return self._m_has_field_crystal_exp_material_id self._m_has_field_crystal_exp_material_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_crystal_exp_material_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_boss_challenge_reward_range(self): if hasattr(self, '_m_has_field_boss_challenge_reward_range'): return self._m_has_field_boss_challenge_reward_range self._m_has_field_boss_challenge_reward_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_boss_challenge_reward_range', None) @property def has_field_all_radar_open_level(self): if hasattr(self, '_m_has_field_all_radar_open_level'): return self._m_has_field_all_radar_open_level self._m_has_field_all_radar_open_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_all_radar_open_level', None) @property def has_field_statue_group_id(self): if hasattr(self, '_m_has_field_statue_group_id'): return self._m_has_field_statue_group_id self._m_has_field_statue_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_statue_group_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ShopRecommendTagTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InvolveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementCoeffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_crash_co: self.crash_co = self._io.read_f4le() if self.has_field_element_level_co: self.element_level_co = self._io.read_f4le() if self.has_field_player_element_level_co: self.player_element_level_co = self._io.read_f4le() if self.has_field_player_shield_level_co: self.player_shield_level_co = self._io.read_f4le() @property def has_field_element_level_co(self): if hasattr(self, '_m_has_field_element_level_co'): return self._m_has_field_element_level_co self._m_has_field_element_level_co = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_element_level_co', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_crash_co(self): if hasattr(self, '_m_has_field_crash_co'): return self._m_has_field_crash_co self._m_has_field_crash_co = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_crash_co', None) @property def has_field_player_element_level_co(self): if hasattr(self, '_m_has_field_player_element_level_co'): return self._m_has_field_player_element_level_co self._m_has_field_player_element_level_co = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_player_element_level_co', None) @property def has_field_player_shield_level_co(self): if hasattr(self, '_m_has_field_player_shield_level_co'): return self._m_has_field_player_shield_level_co self._m_has_field_player_shield_level_co = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_player_shield_level_co', None) class IndicatorDistanceInfoTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityDeliveryDailyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_daily_config_id: self.daily_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delivery_quest_config: self.delivery_quest_config = Output.ArrayOfDeliveryQuestConfigLengthS(self._io, self, self._root) if self.has_field_task_desc: self.task_desc = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_daily_reward_id: self.daily_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_daily_config_id(self): if hasattr(self, '_m_has_field_daily_config_id'): return self._m_has_field_daily_config_id self._m_has_field_daily_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_daily_config_id', None) @property def has_field_delivery_quest_config(self): if hasattr(self, '_m_has_field_delivery_quest_config'): return self._m_has_field_delivery_quest_config self._m_has_field_delivery_quest_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_delivery_quest_config', None) @property def has_field_task_desc(self): if hasattr(self, '_m_has_field_task_desc'): return self._m_has_field_task_desc self._m_has_field_task_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_task_desc', None) @property def has_field_daily_reward_id(self): if hasattr(self, '_m_has_field_daily_reward_id'): return self._m_has_field_daily_reward_id self._m_has_field_daily_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_daily_reward_id', None) class CreatureExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_hp_base: self.hp_base = self._io.read_f4le() if self.has_field_attack_base: self.attack_base = self._io.read_f4le() if self.has_field_defense_base: self.defense_base = self._io.read_f4le() if self.has_field_critical: self.critical = self._io.read_f4le() if self.has_field_anti_critical: self.anti_critical = self._io.read_f4le() if self.has_field_critical_hurt: self.critical_hurt = self._io.read_f4le() if self.has_field_fire_sub_hurt: self.fire_sub_hurt = self._io.read_f4le() if self.has_field_grass_sub_hurt: self.grass_sub_hurt = self._io.read_f4le() if self.has_field_water_sub_hurt: self.water_sub_hurt = self._io.read_f4le() if self.has_field_elec_sub_hurt: self.elec_sub_hurt = self._io.read_f4le() if self.has_field_wind_sub_hurt: self.wind_sub_hurt = self._io.read_f4le() if self.has_field_ice_sub_hurt: self.ice_sub_hurt = self._io.read_f4le() if self.has_field_rock_sub_hurt: self.rock_sub_hurt = self._io.read_f4le() if self.has_field_fire_add_hurt: self.fire_add_hurt = self._io.read_f4le() if self.has_field_grass_add_hurt: self.grass_add_hurt = self._io.read_f4le() if self.has_field_water_add_hurt: self.water_add_hurt = self._io.read_f4le() if self.has_field_elec_add_hurt: self.elec_add_hurt = self._io.read_f4le() if self.has_field_wind_add_hurt: self.wind_add_hurt = self._io.read_f4le() if self.has_field_ice_add_hurt: self.ice_add_hurt = self._io.read_f4le() if self.has_field_rock_add_hurt: self.rock_add_hurt = self._io.read_f4le() if self.has_field_prop_grow_curves: self.prop_grow_curves = Output.ArrayOfFightPropGrowConfigLengthS(self._io, self, self._root) if self.has_field_element_mastery: self.element_mastery = self._io.read_f4le() if self.has_field_physical_sub_hurt: self.physical_sub_hurt = self._io.read_f4le() if self.has_field_physical_add_hurt: self.physical_add_hurt = self._io.read_f4le() if self.has_field_prefab_path_ragdoll_hash: self.prefab_path_ragdoll_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_ragdoll_hash: self.prefab_path_ragdoll_hash_pre = self._io.read_s1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_pre = self._io.read_s1() if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_pre = self._io.read_s1() if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_pre = self._io.read_s1() if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_critical(self): if hasattr(self, '_m_has_field_critical'): return self._m_has_field_critical self._m_has_field_critical = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_critical', None) @property def has_field_rock_add_hurt(self): if hasattr(self, '_m_has_field_rock_add_hurt'): return self._m_has_field_rock_add_hurt self._m_has_field_rock_add_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_rock_add_hurt', None) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_camp_id', None) @property def has_field_fire_sub_hurt(self): if hasattr(self, '_m_has_field_fire_sub_hurt'): return self._m_has_field_fire_sub_hurt self._m_has_field_fire_sub_hurt = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_fire_sub_hurt', None) @property def has_field_physical_sub_hurt(self): if hasattr(self, '_m_has_field_physical_sub_hurt'): return self._m_has_field_physical_sub_hurt self._m_has_field_physical_sub_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_physical_sub_hurt', None) @property def has_field_attack_base(self): if hasattr(self, '_m_has_field_attack_base'): return self._m_has_field_attack_base self._m_has_field_attack_base = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_attack_base', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_hp_base(self): if hasattr(self, '_m_has_field_hp_base'): return self._m_has_field_hp_base self._m_has_field_hp_base = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_hp_base', None) @property def has_field_ice_sub_hurt(self): if hasattr(self, '_m_has_field_ice_sub_hurt'): return self._m_has_field_ice_sub_hurt self._m_has_field_ice_sub_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_ice_sub_hurt', None) @property def has_field_ice_add_hurt(self): if hasattr(self, '_m_has_field_ice_add_hurt'): return self._m_has_field_ice_add_hurt self._m_has_field_ice_add_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_ice_add_hurt', None) @property def has_field_wind_sub_hurt(self): if hasattr(self, '_m_has_field_wind_sub_hurt'): return self._m_has_field_wind_sub_hurt self._m_has_field_wind_sub_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_wind_sub_hurt', None) @property def has_field_elec_sub_hurt(self): if hasattr(self, '_m_has_field_elec_sub_hurt'): return self._m_has_field_elec_sub_hurt self._m_has_field_elec_sub_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_elec_sub_hurt', None) @property def has_field_fire_add_hurt(self): if hasattr(self, '_m_has_field_fire_add_hurt'): return self._m_has_field_fire_add_hurt self._m_has_field_fire_add_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_fire_add_hurt', None) @property def has_field_grass_sub_hurt(self): if hasattr(self, '_m_has_field_grass_sub_hurt'): return self._m_has_field_grass_sub_hurt self._m_has_field_grass_sub_hurt = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_grass_sub_hurt', None) @property def has_field_elec_add_hurt(self): if hasattr(self, '_m_has_field_elec_add_hurt'): return self._m_has_field_elec_add_hurt self._m_has_field_elec_add_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_elec_add_hurt', None) @property def has_field_physical_add_hurt(self): if hasattr(self, '_m_has_field_physical_add_hurt'): return self._m_has_field_physical_add_hurt self._m_has_field_physical_add_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_physical_add_hurt', None) @property def has_field_element_mastery(self): if hasattr(self, '_m_has_field_element_mastery'): return self._m_has_field_element_mastery self._m_has_field_element_mastery = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_element_mastery', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_wind_add_hurt(self): if hasattr(self, '_m_has_field_wind_add_hurt'): return self._m_has_field_wind_add_hurt self._m_has_field_wind_add_hurt = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_wind_add_hurt', None) @property def has_field_anti_critical(self): if hasattr(self, '_m_has_field_anti_critical'): return self._m_has_field_anti_critical self._m_has_field_anti_critical = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_anti_critical', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_water_sub_hurt(self): if hasattr(self, '_m_has_field_water_sub_hurt'): return self._m_has_field_water_sub_hurt self._m_has_field_water_sub_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_water_sub_hurt', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_defense_base(self): if hasattr(self, '_m_has_field_defense_base'): return self._m_has_field_defense_base self._m_has_field_defense_base = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_defense_base', None) @property def has_field_critical_hurt(self): if hasattr(self, '_m_has_field_critical_hurt'): return self._m_has_field_critical_hurt self._m_has_field_critical_hurt = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_critical_hurt', None) @property def has_field_water_add_hurt(self): if hasattr(self, '_m_has_field_water_add_hurt'): return self._m_has_field_water_add_hurt self._m_has_field_water_add_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_water_add_hurt', None) @property def has_field_rock_sub_hurt(self): if hasattr(self, '_m_has_field_rock_sub_hurt'): return self._m_has_field_rock_sub_hurt self._m_has_field_rock_sub_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_rock_sub_hurt', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_grass_add_hurt(self): if hasattr(self, '_m_has_field_grass_add_hurt'): return self._m_has_field_grass_add_hurt self._m_has_field_grass_add_hurt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_grass_add_hurt', None) @property def has_field_prop_grow_curves(self): if hasattr(self, '_m_has_field_prop_grow_curves'): return self._m_has_field_prop_grow_curves self._m_has_field_prop_grow_curves = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_prop_grow_curves', None) @property def has_field_prefab_path_ragdoll_hash(self): if hasattr(self, '_m_has_field_prefab_path_ragdoll_hash'): return self._m_has_field_prefab_path_ragdoll_hash self._m_has_field_prefab_path_ragdoll_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_prefab_path_ragdoll_hash', None) class ConfigWidgetToyAdeptiAbode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetToyCreateGadgetBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_last_time: self.effect_last_time = self._io.read_f4le() @property def is_set_camera(self): if hasattr(self, '_m_is_set_camera'): return self._m_is_set_camera self._m_is_set_camera = self.base.is_set_camera return getattr(self, '_m_is_set_camera', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def has_field_effect_last_time(self): if hasattr(self, '_m_has_field_effect_last_time'): return self._m_has_field_effect_last_time self._m_has_field_effect_last_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_last_time', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def set_camera_angle(self): if hasattr(self, '_m_set_camera_angle'): return self._m_set_camera_angle self._m_set_camera_angle = self.base.set_camera_angle return getattr(self, '_m_set_camera_angle', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def do_bag_type(self): if hasattr(self, '_m_do_bag_type'): return self._m_do_bag_type self._m_do_bag_type = self.base.do_bag_type return getattr(self, '_m_do_bag_type', None) class ConfigAbilityAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_token: self.token = Output.ConfigAbilityActionToken(self._io, self, self._root) if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_do_off_stage: self.do_off_stage = self._io.read_u1() if self.has_field_do_after_die: self.do_after_die = self._io.read_u1() if self.has_field_can_be_handled_on_recover: self.can_be_handled_on_recover = self._io.read_u1() if self.has_field_mute_remote_action: self.mute_remote_action = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_predicates_foreach: self.predicates_foreach = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_mute_remote_action(self): if hasattr(self, '_m_has_field_mute_remote_action'): return self._m_has_field_mute_remote_action self._m_has_field_mute_remote_action = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_mute_remote_action', None) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_token(self): if hasattr(self, '_m_has_field_token'): return self._m_has_field_token self._m_has_field_token = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_token', None) @property def has_field_do_off_stage(self): if hasattr(self, '_m_has_field_do_off_stage'): return self._m_has_field_do_off_stage self._m_has_field_do_off_stage = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_do_off_stage', None) @property def has_field_can_be_handled_on_recover(self): if hasattr(self, '_m_has_field_can_be_handled_on_recover'): return self._m_has_field_can_be_handled_on_recover self._m_has_field_can_be_handled_on_recover = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_can_be_handled_on_recover', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_do_after_die(self): if hasattr(self, '_m_has_field_do_after_die'): return self._m_has_field_do_after_die self._m_has_field_do_after_die = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_do_after_die', None) @property def has_field_predicates_foreach(self): if hasattr(self, '_m_has_field_predicates_foreach'): return self._m_has_field_predicates_foreach self._m_has_field_predicates_foreach = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_predicates_foreach', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_target', None) class FireHitEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_entity: self.hit_entity = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_scene: self.hit_scene = Output.ConfigHitScene(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_hit_scene(self): if hasattr(self, '_m_has_field_hit_scene'): return self._m_has_field_hit_scene self._m_has_field_hit_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hit_scene', None) @property def has_field_hit_entity(self): if hasattr(self, '_m_has_field_hit_entity'): return self._m_has_field_hit_entity self._m_has_field_hit_entity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_entity', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class CoopChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairDungeonStatExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFleurFairMiniGameType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FleurFairMiniGameType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfIrodoriChessCardEffectLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IrodoriChessCardEffect(self._io, self, self._root)) class EnumCreaterDir(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CreaterDir, self.data.value) return getattr(self, '_m_value', None) class EnumQteStepButtonSlideDirectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepButtonSlideDirectType, self.data.value) return getattr(self, '_m_value', None) class ConfigRecordActorInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_prefab_hash: self.prefab_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_serial_id: self.serial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_actor_type: self.actor_type = Output.EnumRecordActorType(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_actor_type(self): if hasattr(self, '_m_has_field_actor_type'): return self._m_has_field_actor_type self._m_has_field_actor_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_actor_type', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_serial_id(self): if hasattr(self, '_m_has_field_serial_id'): return self._m_has_field_serial_id self._m_has_field_serial_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_serial_id', None) @property def has_field_prefab_hash(self): if hasattr(self, '_m_has_field_prefab_hash'): return self._m_has_field_prefab_hash self._m_has_field_prefab_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_prefab_hash', None) class FieldTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEnvironmentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EnvironmentType, self.data.value) return getattr(self, '_m_value', None) class SceneTagConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_tag_name: self.scene_tag_name = AuxTypes.String(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_valid: self.is_default_valid = self._io.read_u1() if self.has_field_is_skip_loading: self.is_skip_loading = self._io.read_u1() if self.has_field_is_independent: self.is_independent = self._io.read_u1() if self.has_field_cond: self.cond = Output.ArrayOfSceneTagCondLengthS(self._io, self, self._root) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_is_independent(self): if hasattr(self, '_m_has_field_is_independent'): return self._m_has_field_is_independent self._m_has_field_is_independent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_independent', None) @property def has_field_is_default_valid(self): if hasattr(self, '_m_has_field_is_default_valid'): return self._m_has_field_is_default_valid self._m_has_field_is_default_valid = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_default_valid', None) @property def has_field_scene_tag_name(self): if hasattr(self, '_m_has_field_scene_tag_name'): return self._m_has_field_scene_tag_name self._m_has_field_scene_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_tag_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_is_skip_loading(self): if hasattr(self, '_m_has_field_is_skip_loading'): return self._m_has_field_is_skip_loading self._m_has_field_is_skip_loading = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_skip_loading', None) class ReTriggerAiSkillInitialCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_i_ds: self.skill_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_force_reinit: self.force_reinit = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_force_reinit(self): if hasattr(self, '_m_has_field_force_reinit'): return self._m_has_field_force_reinit self._m_has_field_force_reinit = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_force_reinit', None) @property def has_field_skill_i_ds(self): if hasattr(self, '_m_has_field_skill_i_ds'): return self._m_has_field_skill_i_ds self._m_has_field_skill_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_i_ds', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigGraphicsSettingEntryLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGraphicsSettingEntry(self._io, self, self._root)) class ConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGearJigsawExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CompoundExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumCompoundType(self._io, self, self._root) if self.has_field_is_default_unlocked: self.is_default_unlocked = self._io.read_u1() if self.has_field_cost_time: self.cost_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_queue_size: self.queue_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_input_vec: self.input_vec = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_output_vec: self.output_vec = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count_desc: self.count_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_count_desc(self): if hasattr(self, '_m_has_field_count_desc'): return self._m_has_field_count_desc self._m_has_field_count_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_count_desc', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_output_vec(self): if hasattr(self, '_m_has_field_output_vec'): return self._m_has_field_output_vec self._m_has_field_output_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_output_vec', None) @property def has_field_cost_time(self): if hasattr(self, '_m_has_field_cost_time'): return self._m_has_field_cost_time self._m_has_field_cost_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cost_time', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_is_default_unlocked(self): if hasattr(self, '_m_has_field_is_default_unlocked'): return self._m_has_field_is_default_unlocked self._m_has_field_is_default_unlocked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_default_unlocked', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_queue_size(self): if hasattr(self, '_m_has_field_queue_size'): return self._m_has_field_queue_size self._m_has_field_queue_size = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_queue_size', None) @property def has_field_input_vec(self): if hasattr(self, '_m_has_field_input_vec'): return self._m_has_field_input_vec self._m_has_field_input_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_input_vec', None) class CustomLevelGroupConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_list: self.dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_activity_dungeon_list: self.activity_dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_edit_count: self.max_edit_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_store_max_count: self.store_max_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_challenge_id: self.coin_challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_exhibition_id: self.coin_exhibition_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_exhibition_id: self.finish_exhibition_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_alert: self.cost_alert = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_coin_challenge_id(self): if hasattr(self, '_m_has_field_coin_challenge_id'): return self._m_has_field_coin_challenge_id self._m_has_field_coin_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_coin_challenge_id', None) @property def has_field_activity_dungeon_list(self): if hasattr(self, '_m_has_field_activity_dungeon_list'): return self._m_has_field_activity_dungeon_list self._m_has_field_activity_dungeon_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_dungeon_list', None) @property def has_field_cost_alert(self): if hasattr(self, '_m_has_field_cost_alert'): return self._m_has_field_cost_alert self._m_has_field_cost_alert = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cost_alert', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_dungeon_list(self): if hasattr(self, '_m_has_field_dungeon_list'): return self._m_has_field_dungeon_list self._m_has_field_dungeon_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_list', None) @property def has_field_finish_exhibition_id(self): if hasattr(self, '_m_has_field_finish_exhibition_id'): return self._m_has_field_finish_exhibition_id self._m_has_field_finish_exhibition_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_finish_exhibition_id', None) @property def has_field_coin_exhibition_id(self): if hasattr(self, '_m_has_field_coin_exhibition_id'): return self._m_has_field_coin_exhibition_id self._m_has_field_coin_exhibition_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_coin_exhibition_id', None) @property def has_field_store_max_count(self): if hasattr(self, '_m_has_field_store_max_count'): return self._m_has_field_store_max_count self._m_has_field_store_max_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_store_max_count', None) @property def has_field_max_edit_count(self): if hasattr(self, '_m_has_field_max_edit_count'): return self._m_has_field_max_edit_count self._m_has_field_max_edit_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_edit_count', None) class EnumGetPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GetPosType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfAiPointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AiPoint(self._io, self, self._root)) class IrodoriPoetryScanConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_index_id_list: self.index_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_line_id: self.line_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_index_id_list(self): if hasattr(self, '_m_has_field_index_id_list'): return self._m_has_field_index_id_list self._m_has_field_index_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_index_id_list', None) @property def has_field_line_id(self): if hasattr(self, '_m_has_field_line_id'): return self._m_has_field_line_id self._m_has_field_line_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_line_id', None) class SalesmanSpecialRewardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuidePlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuidePlatform, self.data.value) return getattr(self, '_m_value', None) class StrengthenBasePointExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_type: self.dungeon_type = Output.EnumStrengthenDungeonType(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_dungeon_type(self): if hasattr(self, '_m_has_field_dungeon_type'): return self._m_has_field_dungeon_type self._m_has_field_dungeon_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_type', None) class EnumUiInteractType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UiInteractType, self.data.value) return getattr(self, '_m_value', None) class TreasureMapBonusRegionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_region_id: self.unlock_region_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_title: self.map_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_desc: self.map_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_image: self.show_image = AuxTypes.String(self._io, self, self._root) if self.has_field_fragment_num: self.fragment_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_center: self.region_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_region_radius: self.region_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_map_desc(self): if hasattr(self, '_m_has_field_map_desc'): return self._m_has_field_map_desc self._m_has_field_map_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_map_desc', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_region_radius(self): if hasattr(self, '_m_has_field_region_radius'): return self._m_has_field_region_radius self._m_has_field_region_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_region_radius', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_unlock_region_id(self): if hasattr(self, '_m_has_field_unlock_region_id'): return self._m_has_field_unlock_region_id self._m_has_field_unlock_region_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_region_id', None) @property def has_field_region_center(self): if hasattr(self, '_m_has_field_region_center'): return self._m_has_field_region_center self._m_has_field_region_center = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_region_center', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_fragment_num(self): if hasattr(self, '_m_has_field_fragment_num'): return self._m_has_field_fragment_num self._m_has_field_fragment_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_fragment_num', None) @property def has_field_show_image(self): if hasattr(self, '_m_has_field_show_image'): return self._m_has_field_show_image self._m_has_field_show_image = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_show_image', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_revise_level', None) @property def has_field_map_title(self): if hasattr(self, '_m_has_field_map_title'): return self._m_has_field_map_title self._m_has_field_map_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_map_title', None) class ConfigCameraRadialBlur(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_power: self.power = self._io.read_f4le() if self.has_field_blur_time: self.blur_time = self._io.read_f4le() if self.has_field_fade_time: self.fade_time = self._io.read_f4le() @property def has_field_power(self): if hasattr(self, '_m_has_field_power'): return self._m_has_field_power self._m_has_field_power = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_power', None) @property def has_field_blur_time(self): if hasattr(self, '_m_has_field_blur_time'): return self._m_has_field_blur_time self._m_has_field_blur_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_blur_time', None) @property def has_field_fade_time(self): if hasattr(self, '_m_has_field_fade_time'): return self._m_has_field_fade_time self._m_has_field_fade_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fade_time', None) class TryTriggerPlatformStartMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_detect_height: self.detect_height = self._io.read_f4le() if self.has_field_detect_width: self.detect_width = self._io.read_f4le() if self.has_field_enable_rotation_offset: self.enable_rotation_offset = self._io.read_u1() if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_force_reset: self.force_reset = self._io.read_u1() if self.has_field_force_trigger: self.force_trigger = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fail_actions', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_detect_height(self): if hasattr(self, '_m_has_field_detect_height'): return self._m_has_field_detect_height self._m_has_field_detect_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_detect_height', None) @property def has_field_force_reset(self): if hasattr(self, '_m_has_field_force_reset'): return self._m_has_field_force_reset self._m_has_field_force_reset = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_force_reset', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_force_trigger(self): if hasattr(self, '_m_has_field_force_trigger'): return self._m_has_field_force_trigger self._m_has_field_force_trigger = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_force_trigger', None) @property def has_field_detect_width(self): if hasattr(self, '_m_has_field_detect_width'): return self._m_has_field_detect_width self._m_has_field_detect_width = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_width', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_enable_rotation_offset(self): if hasattr(self, '_m_has_field_enable_rotation_offset'): return self._m_has_field_enable_rotation_offset self._m_has_field_enable_rotation_offset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enable_rotation_offset', None) class ArrayOfConfigEntityBlackGrpLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEntityBlackGrp(self._io, self, self._root)) class SyncEntityPositionByNormalizedTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_normalized_time: self.normalized_time = self._io.read_f4le() @property def has_field_normalized_time(self): if hasattr(self, '_m_has_field_normalized_time'): return self._m_has_field_normalized_time self._m_has_field_normalized_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_normalized_time', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigPlatformPerfSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_perf_rating: self.perf_rating = Output.ConfigPerfRatingSetting(self._io, self, self._root) if self.has_field_perf_options: self.perf_options = Output.ConfigPerfSettingSet(self._io, self, self._root) if self.has_field_player_custom_options: self.player_custom_options = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_apply_global_perf_for_graphic_setting: self.apply_global_perf_for_graphic_setting = self._io.read_u1() if self.has_field_cost_ratio_grade: self.cost_ratio_grade = Output.DictOfEnumPerfCostRatioGradeF4(self._io, self, self._root) @property def has_field_perf_rating(self): if hasattr(self, '_m_has_field_perf_rating'): return self._m_has_field_perf_rating self._m_has_field_perf_rating = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_perf_rating', None) @property def has_field_perf_options(self): if hasattr(self, '_m_has_field_perf_options'): return self._m_has_field_perf_options self._m_has_field_perf_options = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_perf_options', None) @property def has_field_player_custom_options(self): if hasattr(self, '_m_has_field_player_custom_options'): return self._m_has_field_player_custom_options self._m_has_field_player_custom_options = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_player_custom_options', None) @property def has_field_cost_ratio_grade(self): if hasattr(self, '_m_has_field_cost_ratio_grade'): return self._m_has_field_cost_ratio_grade self._m_has_field_cost_ratio_grade = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_cost_ratio_grade', None) @property def has_field_apply_global_perf_for_graphic_setting(self): if hasattr(self, '_m_has_field_apply_global_perf_for_graphic_setting'): return self._m_has_field_apply_global_perf_for_graphic_setting self._m_has_field_apply_global_perf_for_graphic_setting = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_apply_global_perf_for_graphic_setting', None) class EnumMarkViewType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkViewType, self.data.value) return getattr(self, '_m_value', None) class AsterMidGroupsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_group_vec: self.battle_group_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_battle_group_vec(self): if hasattr(self, '_m_has_field_battle_group_vec'): return self._m_has_field_battle_group_vec self._m_has_field_battle_group_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_battle_group_vec', None) class RogueGadgetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_type: self.gadget_type = Output.EnumRogueCreateGadgetType(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_state_config_list: self.gadget_state_config_list = Output.ArrayOfRogueGadgetStateConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_gadget_type(self): if hasattr(self, '_m_has_field_gadget_type'): return self._m_has_field_gadget_type self._m_has_field_gadget_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_type', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_gadget_state_config_list(self): if hasattr(self, '_m_has_field_gadget_state_config_list'): return self._m_has_field_gadget_state_config_list self._m_has_field_gadget_state_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gadget_state_config_list', None) class EnumHomeAvatarEventCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HomeAvatarEventCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigHomeFurnitureSuite(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_suite_id: self.suite_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spawn_pos: self.spawn_pos = Output.Vector(self._io, self, self._root) if self.has_field_included_furniture_index_list: self.included_furniture_index_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_suite_id(self): if hasattr(self, '_m_has_field_suite_id'): return self._m_has_field_suite_id self._m_has_field_suite_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_suite_id', None) @property def has_field_spawn_pos(self): if hasattr(self, '_m_has_field_spawn_pos'): return self._m_has_field_spawn_pos self._m_has_field_spawn_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_pos', None) @property def has_field_included_furniture_index_list(self): if hasattr(self, '_m_has_field_included_furniture_index_list'): return self._m_has_field_included_furniture_index_list self._m_has_field_included_furniture_index_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_included_furniture_index_list', None) class DictOfAuxTypesStringDispConfigClimateInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigClimateInfoBase(self._io, self, self._root)) class ChangeLockTypeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lock_type: self.lock_type = AuxTypes.String(self._io, self, self._root) if self.has_field_override_range: self.override_range = self._io.read_f4le() if self.has_field_override_normal_pri: self.override_normal_pri = self._io.read_f4le() if self.has_field_override_combat_pri: self.override_combat_pri = self._io.read_f4le() @property def has_field_override_combat_pri(self): if hasattr(self, '_m_has_field_override_combat_pri'): return self._m_has_field_override_combat_pri self._m_has_field_override_combat_pri = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_override_combat_pri', None) @property def has_field_lock_type(self): if hasattr(self, '_m_has_field_lock_type'): return self._m_has_field_lock_type self._m_has_field_lock_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lock_type', None) @property def has_field_override_range(self): if hasattr(self, '_m_has_field_override_range'): return self._m_has_field_override_range self._m_has_field_override_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_override_range', None) @property def has_field_override_normal_pri(self): if hasattr(self, '_m_has_field_override_normal_pri'): return self._m_has_field_override_normal_pri self._m_has_field_override_normal_pri = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_normal_pri', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigJudgeNodeContainer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_sub_nodes: self.sub_nodes = Output.ArrayOfDispConfigJudgeNodeBaseLengthU(self._io, self, self._root) if self.has_field_sub_node_logic_comb: self.sub_node_logic_comb = Output.EnumLogicType(self._io, self, self._root) @property def has_field_sub_nodes(self): if hasattr(self, '_m_has_field_sub_nodes'): return self._m_has_field_sub_nodes self._m_has_field_sub_nodes = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sub_nodes', None) @property def has_field_sub_node_logic_comb(self): if hasattr(self, '_m_has_field_sub_node_logic_comb'): return self._m_has_field_sub_node_logic_comb self._m_has_field_sub_node_logic_comb = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sub_node_logic_comb', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class RandomQuestElemPoolExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGearExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabBuffCostExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_quality_type: self.buff_quality_type = Output.EnumQualityType(self._io, self, self._root) if self.has_field_buff_cost: self.buff_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_buff_cost(self): if hasattr(self, '_m_has_field_buff_cost'): return self._m_has_field_buff_cost self._m_has_field_buff_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_buff_cost', None) @property def has_field_buff_quality_type(self): if hasattr(self, '_m_has_field_buff_quality_type'): return self._m_has_field_buff_quality_type self._m_has_field_buff_quality_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_buff_quality_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class CusmtomGadgetSlotExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelTagArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMist(self._io, self, self._root) @property def sort_id(self): if hasattr(self, '_m_sort_id'): return self._m_sort_id self._m_sort_id = self.base.sort_id return getattr(self, '_m_sort_id', None) @property def need_anim(self): if hasattr(self, '_m_need_anim'): return self._m_need_anim self._m_need_anim = self.base.need_anim return getattr(self, '_m_need_anim', None) @property def map_pos_list(self): if hasattr(self, '_m_map_pos_list'): return self._m_map_pos_list self._m_map_pos_list = self.base.map_pos_list return getattr(self, '_m_map_pos_list', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) @property def show_unlock_scene_point(self): if hasattr(self, '_m_show_unlock_scene_point'): return self._m_show_unlock_scene_point self._m_show_unlock_scene_point = self.base.show_unlock_scene_point return getattr(self, '_m_show_unlock_scene_point', None) @property def prefab_path(self): if hasattr(self, '_m_prefab_path'): return self._m_prefab_path self._m_prefab_path = self.base.prefab_path return getattr(self, '_m_prefab_path', None) @property def hide_scene_point_list(self): if hasattr(self, '_m_hide_scene_point_list'): return self._m_hide_scene_point_list self._m_hide_scene_point_list = self.base.hide_scene_point_list return getattr(self, '_m_hide_scene_point_list', None) class ConfigWidgetOpenPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_page_name: self.page_name = AuxTypes.String(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_page_name(self): if hasattr(self, '_m_has_field_page_name'): return self._m_has_field_page_name self._m_has_field_page_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_page_name', None) class ConfigMusicDoubleEqualityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class AnimeGroupTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WatcherSystemMixinTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumWidgetEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetEventType, self.data.value) return getattr(self, '_m_value', None) class HomeWorldAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReputationFunctionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_function_id: self.function_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shop_desc: self.shop_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_function_id(self): if hasattr(self, '_m_has_field_function_id'): return self._m_has_field_function_id self._m_has_field_function_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_function_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_shop_desc(self): if hasattr(self, '_m_has_field_shop_desc'): return self._m_has_field_shop_desc self._m_has_field_shop_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_shop_desc', None) class EnumDialogSteerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DialogSteerType, self.data.value) return getattr(self, '_m_value', None) class CaptureTagsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispBornRandom(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.BornRandom(self._io, self, self._root) elif _on == 1: self.data = Output.BornRandomFromCenter(self._io, self, self._root) elif _on == 2: self.data = Output.BornRandomInShape(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigGuideCameraControlAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) class SectrCombineStreamPathInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_layer_loader_path_hash: self.layer_loader_path_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_platform_layers: self.platform_layers = Output.ArrayOfSectrPlatformStreamLayerLengthU(self._io, self, self._root) @property def has_field_layer_loader_path_hash(self): if hasattr(self, '_m_has_field_layer_loader_path_hash'): return self._m_has_field_layer_loader_path_hash self._m_has_field_layer_loader_path_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_layer_loader_path_hash', None) @property def has_field_platform_layers(self): if hasattr(self, '_m_has_field_platform_layers'): return self._m_has_field_platform_layers self._m_has_field_platform_layers = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_platform_layers', None) class ReputationFunctionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfRogueSequenceCellConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RogueSequenceCellConfig(self._io, self, self._root)) class ConfigBoatMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigVehicleMove(self._io, self, self._root) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class ConfigHomeworldFurnitureUnit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_parent_index: self.parent_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_parent_index(self): if hasattr(self, '_m_has_field_parent_index'): return self._m_has_field_parent_index self._m_has_field_parent_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_parent_index', None) class SteerAttackMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_steer_state_i_ds: self.steer_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_start_normalized_time: self.start_normalized_time = self._io.read_f4le() if self.has_field_end_normalized_time: self.end_normalized_time = self._io.read_f4le() if self.has_field_angular_speed: self.angular_speed = self._io.read_f4le() if self.has_field_attack_angle: self.attack_angle = self._io.read_f4le() if self.has_field_attack_trigger: self.attack_trigger = AuxTypes.String(self._io, self, self._root) if self.has_field_attack_distance: self.attack_distance = self._io.read_f4le() if self.has_field_remote_steer_to_local_target: self.remote_steer_to_local_target = self._io.read_u1() if self.has_field_facing_target_types: self.facing_target_types = Output.ArrayOfEnumSteerAttackTargetTypeLengthU(self._io, self, self._root) @property def has_field_steer_state_i_ds(self): if hasattr(self, '_m_has_field_steer_state_i_ds'): return self._m_has_field_steer_state_i_ds self._m_has_field_steer_state_i_ds = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_steer_state_i_ds', None) @property def has_field_attack_distance(self): if hasattr(self, '_m_has_field_attack_distance'): return self._m_has_field_attack_distance self._m_has_field_attack_distance = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_attack_distance', None) @property def has_field_start_normalized_time(self): if hasattr(self, '_m_has_field_start_normalized_time'): return self._m_has_field_start_normalized_time self._m_has_field_start_normalized_time = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_start_normalized_time', None) @property def has_field_attack_trigger(self): if hasattr(self, '_m_has_field_attack_trigger'): return self._m_has_field_attack_trigger self._m_has_field_attack_trigger = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_attack_trigger', None) @property def has_field_facing_target_types(self): if hasattr(self, '_m_has_field_facing_target_types'): return self._m_has_field_facing_target_types self._m_has_field_facing_target_types = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_facing_target_types', None) @property def has_field_end_normalized_time(self): if hasattr(self, '_m_has_field_end_normalized_time'): return self._m_has_field_end_normalized_time self._m_has_field_end_normalized_time = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_end_normalized_time', None) @property def has_field_attack_angle(self): if hasattr(self, '_m_has_field_attack_angle'): return self._m_has_field_attack_angle self._m_has_field_attack_angle = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_attack_angle', None) @property def has_field_remote_steer_to_local_target(self): if hasattr(self, '_m_has_field_remote_steer_to_local_target'): return self._m_has_field_remote_steer_to_local_target self._m_has_field_remote_steer_to_local_target = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_remote_steer_to_local_target', None) @property def has_field_angular_speed(self): if hasattr(self, '_m_has_field_angular_speed'): return self._m_has_field_angular_speed self._m_has_field_angular_speed = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_angular_speed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class MarkViewTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfElementConvertToChargeBarValueMixinItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ElementConvertToChargeBarValueMixinItem(self._io, self, self._root)) class ConfigInterActor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_alias: self.alias = AuxTypes.String(self._io, self, self._root) if self.has_field_visible: self.visible = self._io.read_u1() if self.has_field_born_point_name: self.born_point_name = AuxTypes.String(self._io, self, self._root) if self.has_field_use_relative_pos: self.use_relative_pos = self._io.read_u1() if self.has_field_relative_pos: self.relative_pos = Output.Vector(self._io, self, self._root) if self.has_field_relative_rot: self.relative_rot = Output.Vector(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_remove_actor_type: self.remove_actor_type = Output.EnumRemoveActorType(self._io, self, self._root) if self.has_field_force_create_daily: self.force_create_daily = self._io.read_u1() if self.has_field_relative_pos_type: self.relative_pos_type = Output.EnumActorBornRelativePosType(self._io, self, self._root) if self.has_field_relative_pos_npc_alias: self.relative_pos_npc_alias = AuxTypes.String(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_relative_pos_npc_alias(self): if hasattr(self, '_m_has_field_relative_pos_npc_alias'): return self._m_has_field_relative_pos_npc_alias self._m_has_field_relative_pos_npc_alias = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_relative_pos_npc_alias', None) @property def has_field_use_relative_pos(self): if hasattr(self, '_m_has_field_use_relative_pos'): return self._m_has_field_use_relative_pos self._m_has_field_use_relative_pos = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_use_relative_pos', None) @property def has_field_visible(self): if hasattr(self, '_m_has_field_visible'): return self._m_has_field_visible self._m_has_field_visible = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_visible', None) @property def has_field_remove_actor_type(self): if hasattr(self, '_m_has_field_remove_actor_type'): return self._m_has_field_remove_actor_type self._m_has_field_remove_actor_type = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_remove_actor_type', None) @property def has_field_relative_rot(self): if hasattr(self, '_m_has_field_relative_rot'): return self._m_has_field_relative_rot self._m_has_field_relative_rot = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_relative_rot', None) @property def has_field_relative_pos_type(self): if hasattr(self, '_m_has_field_relative_pos_type'): return self._m_has_field_relative_pos_type self._m_has_field_relative_pos_type = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_relative_pos_type', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_alias(self): if hasattr(self, '_m_has_field_alias'): return self._m_has_field_alias self._m_has_field_alias = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_alias', None) @property def has_field_born_point_name(self): if hasattr(self, '_m_has_field_born_point_name'): return self._m_has_field_born_point_name self._m_has_field_born_point_name = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_born_point_name', None) @property def has_field_force_create_daily(self): if hasattr(self, '_m_has_field_force_create_daily'): return self._m_has_field_force_create_daily self._m_has_field_force_create_daily = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_force_create_daily', None) @property def has_field_relative_pos(self): if hasattr(self, '_m_has_field_relative_pos'): return self._m_has_field_relative_pos self._m_has_field_relative_pos = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_relative_pos', None) class KvpOfDictEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumConfigPreloadType(self._io, self, self._root) self.value = Output.ArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) class LanV2fireworksFactorDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiBeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_friendliness: self.friendliness = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_decision_archetype: self.decision_archetype = Output.EnumDecisionArchetype(self._io, self, self._root) if self.has_field_move_setting: self.move_setting = Output.ConfigAiMove(self._io, self, self._root) if self.has_field_precombat: self.precombat = Output.ConfigAiPrecombatSetting(self._io, self, self._root) if self.has_field_ai_combat: self.ai_combat = Output.ConfigAiCombatSetting(self._io, self, self._root) if self.has_field_buddy_setting: self.buddy_setting = Output.ConfigAiBuddySetting(self._io, self, self._root) if self.has_field_sensing: self.sensing = Output.ConfigAiSensing(self._io, self, self._root) if self.has_field_neurons: self.neurons = Output.DictOfAuxTypesStringArrayOfEnumNeuronNameLengthU(self._io, self, self._root) if self.has_field_neuron_setting: self.neuron_setting = Output.ConfigAiNeuronExtSettings(self._io, self, self._root) if self.has_field_threat: self.threat = Output.ConfigAiThreatSetting(self._io, self, self._root) if self.has_field_order: self.order = Output.ConfigAiOrderSetting(self._io, self, self._root) if self.has_field_defend_area: self.defend_area = Output.ConfigAiDefendArea(self._io, self, self._root) if self.has_field_fly: self.fly = Output.ConfigAiFlySetting(self._io, self, self._root) if self.has_field_pose_control: self.pose_control = Output.ConfigAiPoseControl(self._io, self, self._root) if self.has_field_ui: self.ui = Output.ConfigAiuiSetting(self._io, self, self._root) if self.has_field_profiling: self.profiling = Output.ConfigAiProfilingSetting(self._io, self, self._root) if self.has_field_network: self.network = Output.ConfigAiNetworkSetting(self._io, self, self._root) if self.has_field_skill_group_cd_configs: self.skill_group_cd_configs = Output.ArrayOfConfigAiSkillGroupCdLengthU(self._io, self, self._root) if self.has_field_skill_setting: self.skill_setting = Output.ConfigAiSkillSetting(self._io, self, self._root) if self.has_field_skills: self.skills = Output.DictOfAuxTypesStringConfigAiSkill(self._io, self, self._root) if self.has_field_skill_gcd: self.skill_gcd = self._io.read_f4le() if self.has_field_target: self.target = Output.ConfigAiTarget(self._io, self, self._root) if self.has_field_return_to_born_tactic: self.return_to_born_tactic = Output.ConfigAiReturnToBornPosSetting(self._io, self, self._root) if self.has_field_wander_tactic: self.wander_tactic = Output.ConfigAiWanderSetting(self._io, self, self._root) if self.has_field_follow_scripted_path_tactic: self.follow_scripted_path_tactic = Output.ConfigAiFollowScriptedPathSetting(self._io, self, self._root) if self.has_field_follow_server_route_tactic: self.follow_server_route_tactic = Output.ConfigAiFollowServerRouteSetting(self._io, self, self._root) if self.has_field_investigate_tactic: self.investigate_tactic = Output.ConfigAiInvestigateSetting(self._io, self, self._root) if self.has_field_react_action_point_tactic: self.react_action_point_tactic = Output.ConfigAiReactActionPointSetting(self._io, self, self._root) if self.has_field_patrol_follow_tactic: self.patrol_follow_tactic = Output.ConfigAiPatrolFollowSetting(self._io, self, self._root) if self.has_field_combat_follow_move_tactic: self.combat_follow_move_tactic = Output.ConfigAiCombatFollowMoveSetting(self._io, self, self._root) if self.has_field_melee_charge_tactic: self.melee_charge_tactic = Output.ConfigAiMeleeChargeSetting(self._io, self, self._root) if self.has_field_facing_move_tactic: self.facing_move_tactic = Output.ConfigAiFacingMoveSetting(self._io, self, self._root) if self.has_field_surround_tactic: self.surround_tactic = Output.ConfigAiSurroundSetting(self._io, self, self._root) if self.has_field_group_surround_tactic: self.group_surround_tactic = Output.ConfigAiGroupSurroundSetting(self._io, self, self._root) if self.has_field_find_back_tactic: self.find_back_tactic = Output.ConfigAiFindBackSetting(self._io, self, self._root) if self.has_field_combat_fixed_move_tactic: self.combat_fixed_move_tactic = Output.ConfigAiCombatFixedMoveSetting(self._io, self, self._root) if self.has_field_crab_move_tactic: self.crab_move_tactic = Output.ConfigAiCrabMoveSetting(self._io, self, self._root) if self.has_field_flee_tactic: self.flee_tactic = Output.ConfigAiFleeSetting(self._io, self, self._root) if self.has_field_flee_on_block_avatar_landing_tactic: self.flee_on_block_avatar_landing_tactic = Output.ConfigAiFleeOnBlockAvatarLandingSetting(self._io, self, self._root) if self.has_field_spacial_chase_tactic: self.spacial_chase_tactic = Output.ConfigAiSpacialChaseSetting(self._io, self, self._root) if self.has_field_spacial_probe_tactic: self.spacial_probe_tactic = Output.ConfigAiSpacialProbeSetting(self._io, self, self._root) if self.has_field_spacial_adjust_tactic: self.spacial_adjust_tactic = Output.ConfigAiSpacialAdjustSetting(self._io, self, self._root) if self.has_field_spacial_wander_tactic: self.spacial_wander_tactic = Output.ConfigAiSpacialWanderSetting(self._io, self, self._root) if self.has_field_bird_circling_tactic: self.bird_circling_tactic = Output.ConfigAiBirdCirclingSetting(self._io, self, self._root) if self.has_field_scripted_move_to_tactic: self.scripted_move_to_tactic = Output.ConfigAiScriptedMoveToSetting(self._io, self, self._root) if self.has_field_landing_tactic: self.landing_tactic = Output.ConfigAiLandingSetting(self._io, self, self._root) if self.has_field_extraction_tactic: self.extraction_tactic = Output.ConfigAiExtractionSetting(self._io, self, self._root) if self.has_field_brownian_motion_tactic: self.brownian_motion_tactic = Output.ConfigAiBrownianMotionSetting(self._io, self, self._root) if self.has_field_spacial_facing_move_tactic: self.spacial_facing_move_tactic = Output.ConfigAiSpacialFacingMoveSetting(self._io, self, self._root) if self.has_field_mixin: self.mixin = Output.ConfigAiMixinSetting(self._io, self, self._root) if self.has_field_fishing_bites_bait_tactic: self.fishing_bites_bait_tactic = Output.ConfigAiFishingBitesBaitSetting(self._io, self, self._root) if self.has_field_fishing_pretend_bites_tactic: self.fishing_pretend_bites_tactic = Output.ConfigAiFishingPretendBitesSetting(self._io, self, self._root) if self.has_field_fishing_flee_tactic: self.fishing_flee_tactic = Output.ConfigAiFishingFleeSetting(self._io, self, self._root) @property def has_field_decision_archetype(self): if hasattr(self, '_m_has_field_decision_archetype'): return self._m_has_field_decision_archetype self._m_has_field_decision_archetype = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_decision_archetype', None) @property def has_field_investigate_tactic(self): if hasattr(self, '_m_has_field_investigate_tactic'): return self._m_has_field_investigate_tactic self._m_has_field_investigate_tactic = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_investigate_tactic', None) @property def has_field_skill_setting(self): if hasattr(self, '_m_has_field_skill_setting'): return self._m_has_field_skill_setting self._m_has_field_skill_setting = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_skill_setting', None) @property def has_field_find_back_tactic(self): if hasattr(self, '_m_has_field_find_back_tactic'): return self._m_has_field_find_back_tactic self._m_has_field_find_back_tactic = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_find_back_tactic', None) @property def has_field_spacial_facing_move_tactic(self): if hasattr(self, '_m_has_field_spacial_facing_move_tactic'): return self._m_has_field_spacial_facing_move_tactic self._m_has_field_spacial_facing_move_tactic = (self.bit_field.value & 562949953421312) != 0 return getattr(self, '_m_has_field_spacial_facing_move_tactic', None) @property def has_field_wander_tactic(self): if hasattr(self, '_m_has_field_wander_tactic'): return self._m_has_field_wander_tactic self._m_has_field_wander_tactic = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_wander_tactic', None) @property def has_field_group_surround_tactic(self): if hasattr(self, '_m_has_field_group_surround_tactic'): return self._m_has_field_group_surround_tactic self._m_has_field_group_surround_tactic = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_group_surround_tactic', None) @property def has_field_bird_circling_tactic(self): if hasattr(self, '_m_has_field_bird_circling_tactic'): return self._m_has_field_bird_circling_tactic self._m_has_field_bird_circling_tactic = (self.bit_field.value & 17592186044416) != 0 return getattr(self, '_m_has_field_bird_circling_tactic', None) @property def has_field_brownian_motion_tactic(self): if hasattr(self, '_m_has_field_brownian_motion_tactic'): return self._m_has_field_brownian_motion_tactic self._m_has_field_brownian_motion_tactic = (self.bit_field.value & 281474976710656) != 0 return getattr(self, '_m_has_field_brownian_motion_tactic', None) @property def has_field_profiling(self): if hasattr(self, '_m_has_field_profiling'): return self._m_has_field_profiling self._m_has_field_profiling = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_profiling', None) @property def has_field_move_setting(self): if hasattr(self, '_m_has_field_move_setting'): return self._m_has_field_move_setting self._m_has_field_move_setting = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_move_setting', None) @property def has_field_defend_area(self): if hasattr(self, '_m_has_field_defend_area'): return self._m_has_field_defend_area self._m_has_field_defend_area = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_defend_area', None) @property def has_field_facing_move_tactic(self): if hasattr(self, '_m_has_field_facing_move_tactic'): return self._m_has_field_facing_move_tactic self._m_has_field_facing_move_tactic = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_facing_move_tactic', None) @property def has_field_combat_fixed_move_tactic(self): if hasattr(self, '_m_has_field_combat_fixed_move_tactic'): return self._m_has_field_combat_fixed_move_tactic self._m_has_field_combat_fixed_move_tactic = (self.bit_field.value & 68719476736) != 0 return getattr(self, '_m_has_field_combat_fixed_move_tactic', None) @property def has_field_follow_scripted_path_tactic(self): if hasattr(self, '_m_has_field_follow_scripted_path_tactic'): return self._m_has_field_follow_scripted_path_tactic self._m_has_field_follow_scripted_path_tactic = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_follow_scripted_path_tactic', None) @property def has_field_melee_charge_tactic(self): if hasattr(self, '_m_has_field_melee_charge_tactic'): return self._m_has_field_melee_charge_tactic self._m_has_field_melee_charge_tactic = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_melee_charge_tactic', None) @property def has_field_spacial_chase_tactic(self): if hasattr(self, '_m_has_field_spacial_chase_tactic'): return self._m_has_field_spacial_chase_tactic self._m_has_field_spacial_chase_tactic = (self.bit_field.value & 1099511627776) != 0 return getattr(self, '_m_has_field_spacial_chase_tactic', None) @property def has_field_friendliness(self): if hasattr(self, '_m_has_field_friendliness'): return self._m_has_field_friendliness self._m_has_field_friendliness = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_friendliness', None) @property def has_field_network(self): if hasattr(self, '_m_has_field_network'): return self._m_has_field_network self._m_has_field_network = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_network', None) @property def has_field_react_action_point_tactic(self): if hasattr(self, '_m_has_field_react_action_point_tactic'): return self._m_has_field_react_action_point_tactic self._m_has_field_react_action_point_tactic = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_react_action_point_tactic', None) @property def has_field_pose_control(self): if hasattr(self, '_m_has_field_pose_control'): return self._m_has_field_pose_control self._m_has_field_pose_control = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_pose_control', None) @property def has_field_neuron_setting(self): if hasattr(self, '_m_has_field_neuron_setting'): return self._m_has_field_neuron_setting self._m_has_field_neuron_setting = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_neuron_setting', None) @property def has_field_fishing_pretend_bites_tactic(self): if hasattr(self, '_m_has_field_fishing_pretend_bites_tactic'): return self._m_has_field_fishing_pretend_bites_tactic self._m_has_field_fishing_pretend_bites_tactic = (self.bit_field.value & 4503599627370496) != 0 return getattr(self, '_m_has_field_fishing_pretend_bites_tactic', None) @property def has_field_sensing(self): if hasattr(self, '_m_has_field_sensing'): return self._m_has_field_sensing self._m_has_field_sensing = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_sensing', None) @property def has_field_patrol_follow_tactic(self): if hasattr(self, '_m_has_field_patrol_follow_tactic'): return self._m_has_field_patrol_follow_tactic self._m_has_field_patrol_follow_tactic = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_patrol_follow_tactic', None) @property def has_field_fishing_flee_tactic(self): if hasattr(self, '_m_has_field_fishing_flee_tactic'): return self._m_has_field_fishing_flee_tactic self._m_has_field_fishing_flee_tactic = (self.bit_field.value & 9007199254740992) != 0 return getattr(self, '_m_has_field_fishing_flee_tactic', None) @property def has_field_skills(self): if hasattr(self, '_m_has_field_skills'): return self._m_has_field_skills self._m_has_field_skills = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_skills', None) @property def has_field_flee_on_block_avatar_landing_tactic(self): if hasattr(self, '_m_has_field_flee_on_block_avatar_landing_tactic'): return self._m_has_field_flee_on_block_avatar_landing_tactic self._m_has_field_flee_on_block_avatar_landing_tactic = (self.bit_field.value & 549755813888) != 0 return getattr(self, '_m_has_field_flee_on_block_avatar_landing_tactic', None) @property def has_field_extraction_tactic(self): if hasattr(self, '_m_has_field_extraction_tactic'): return self._m_has_field_extraction_tactic self._m_has_field_extraction_tactic = (self.bit_field.value & 140737488355328) != 0 return getattr(self, '_m_has_field_extraction_tactic', None) @property def has_field_spacial_adjust_tactic(self): if hasattr(self, '_m_has_field_spacial_adjust_tactic'): return self._m_has_field_spacial_adjust_tactic self._m_has_field_spacial_adjust_tactic = (self.bit_field.value & 4398046511104) != 0 return getattr(self, '_m_has_field_spacial_adjust_tactic', None) @property def has_field_fly(self): if hasattr(self, '_m_has_field_fly'): return self._m_has_field_fly self._m_has_field_fly = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_fly', None) @property def has_field_ai_combat(self): if hasattr(self, '_m_has_field_ai_combat'): return self._m_has_field_ai_combat self._m_has_field_ai_combat = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_ai_combat', None) @property def has_field_skill_group_cd_configs(self): if hasattr(self, '_m_has_field_skill_group_cd_configs'): return self._m_has_field_skill_group_cd_configs self._m_has_field_skill_group_cd_configs = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_skill_group_cd_configs', None) @property def has_field_precombat(self): if hasattr(self, '_m_has_field_precombat'): return self._m_has_field_precombat self._m_has_field_precombat = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_precombat', None) @property def has_field_buddy_setting(self): if hasattr(self, '_m_has_field_buddy_setting'): return self._m_has_field_buddy_setting self._m_has_field_buddy_setting = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_buddy_setting', None) @property def has_field_combat_follow_move_tactic(self): if hasattr(self, '_m_has_field_combat_follow_move_tactic'): return self._m_has_field_combat_follow_move_tactic self._m_has_field_combat_follow_move_tactic = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_combat_follow_move_tactic', None) @property def has_field_threat(self): if hasattr(self, '_m_has_field_threat'): return self._m_has_field_threat self._m_has_field_threat = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_threat', None) @property def has_field_spacial_probe_tactic(self): if hasattr(self, '_m_has_field_spacial_probe_tactic'): return self._m_has_field_spacial_probe_tactic self._m_has_field_spacial_probe_tactic = (self.bit_field.value & 2199023255552) != 0 return getattr(self, '_m_has_field_spacial_probe_tactic', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_landing_tactic(self): if hasattr(self, '_m_has_field_landing_tactic'): return self._m_has_field_landing_tactic self._m_has_field_landing_tactic = (self.bit_field.value & 70368744177664) != 0 return getattr(self, '_m_has_field_landing_tactic', None) @property def has_field_ui(self): if hasattr(self, '_m_has_field_ui'): return self._m_has_field_ui self._m_has_field_ui = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_ui', None) @property def has_field_scripted_move_to_tactic(self): if hasattr(self, '_m_has_field_scripted_move_to_tactic'): return self._m_has_field_scripted_move_to_tactic self._m_has_field_scripted_move_to_tactic = (self.bit_field.value & 35184372088832) != 0 return getattr(self, '_m_has_field_scripted_move_to_tactic', None) @property def has_field_flee_tactic(self): if hasattr(self, '_m_has_field_flee_tactic'): return self._m_has_field_flee_tactic self._m_has_field_flee_tactic = (self.bit_field.value & 274877906944) != 0 return getattr(self, '_m_has_field_flee_tactic', None) @property def has_field_neurons(self): if hasattr(self, '_m_has_field_neurons'): return self._m_has_field_neurons self._m_has_field_neurons = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_neurons', None) @property def has_field_follow_server_route_tactic(self): if hasattr(self, '_m_has_field_follow_server_route_tactic'): return self._m_has_field_follow_server_route_tactic self._m_has_field_follow_server_route_tactic = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_follow_server_route_tactic', None) @property def has_field_spacial_wander_tactic(self): if hasattr(self, '_m_has_field_spacial_wander_tactic'): return self._m_has_field_spacial_wander_tactic self._m_has_field_spacial_wander_tactic = (self.bit_field.value & 8796093022208) != 0 return getattr(self, '_m_has_field_spacial_wander_tactic', None) @property def has_field_skill_gcd(self): if hasattr(self, '_m_has_field_skill_gcd'): return self._m_has_field_skill_gcd self._m_has_field_skill_gcd = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_skill_gcd', None) @property def has_field_return_to_born_tactic(self): if hasattr(self, '_m_has_field_return_to_born_tactic'): return self._m_has_field_return_to_born_tactic self._m_has_field_return_to_born_tactic = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_return_to_born_tactic', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_target', None) @property def has_field_crab_move_tactic(self): if hasattr(self, '_m_has_field_crab_move_tactic'): return self._m_has_field_crab_move_tactic self._m_has_field_crab_move_tactic = (self.bit_field.value & 137438953472) != 0 return getattr(self, '_m_has_field_crab_move_tactic', None) @property def has_field_fishing_bites_bait_tactic(self): if hasattr(self, '_m_has_field_fishing_bites_bait_tactic'): return self._m_has_field_fishing_bites_bait_tactic self._m_has_field_fishing_bites_bait_tactic = (self.bit_field.value & 2251799813685248) != 0 return getattr(self, '_m_has_field_fishing_bites_bait_tactic', None) @property def has_field_mixin(self): if hasattr(self, '_m_has_field_mixin'): return self._m_has_field_mixin self._m_has_field_mixin = (self.bit_field.value & 1125899906842624) != 0 return getattr(self, '_m_has_field_mixin', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_order', None) @property def has_field_surround_tactic(self): if hasattr(self, '_m_has_field_surround_tactic'): return self._m_has_field_surround_tactic self._m_has_field_surround_tactic = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_surround_tactic', None) class ConfigMusicUInt32noGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ArrayOfBlockLimitLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BlockLimit(self._io, self, self._root)) class DialogSelectTimeOutExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_limit: self.time_limit = self._io.read_f4le() if self.has_field_next_dialog_id: self.next_dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_time_limit(self): if hasattr(self, '_m_has_field_time_limit'): return self._m_has_field_time_limit self._m_has_field_time_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_time_limit', None) @property def has_field_next_dialog_id(self): if hasattr(self, '_m_has_field_next_dialog_id'): return self._m_has_field_next_dialog_id self._m_has_field_next_dialog_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_next_dialog_id', None) class BattlePassScheduleRewardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CardFortuneTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMoveDisableCollision(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_self_colliders: self.self_colliders = Output.ArrayOfConfigEntityColliderLengthU(self._io, self, self._root) if self.has_field_delay_enable_time: self.delay_enable_time = self._io.read_f4le() @property def has_field_self_colliders(self): if hasattr(self, '_m_has_field_self_colliders'): return self._m_has_field_self_colliders self._m_has_field_self_colliders = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_self_colliders', None) @property def has_field_delay_enable_time(self): if hasattr(self, '_m_has_field_delay_enable_time'): return self._m_has_field_delay_enable_time self._m_has_field_delay_enable_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_delay_enable_time', None) class ConfigAiCombatFollowMoveSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiCombatFollowMoveData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiCombatFollowMoveData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigShapePolygon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_polygon_config_path: self.polygon_config_path = AuxTypes.String(self._io, self, self._root) @property def has_field_polygon_config_path(self): if hasattr(self, '_m_has_field_polygon_config_path'): return self._m_has_field_polygon_config_path self._m_has_field_polygon_config_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_polygon_config_path', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) class KvpOfDictAuxTypesStringDispConfigScenePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigScenePoint(self._io, self, self._root) class ConfigAiSkillCastCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pose: self.pose = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_need_re_init_cd: self.need_re_init_cd = self._io.read_u1() if self.has_field_min_target_angle_xz: self.min_target_angle_xz = self._io.read_f4le() if self.has_field_max_target_angle_xz: self.max_target_angle_xz = self._io.read_f4le() if self.has_field_max_target_angle_y: self.max_target_angle_y = self._io.read_f4le() if self.has_field_min_target_angle_y: self.min_target_angle_y = self._io.read_f4le() if self.has_field_pick_range_min: self.pick_range_min = self._io.read_f4le() if self.has_field_pick_range_max: self.pick_range_max = self._io.read_f4le() if self.has_field_pick_range_y_max: self.pick_range_y_max = self._io.read_f4le() if self.has_field_pick_range_y_min: self.pick_range_y_min = self._io.read_f4le() if self.has_field_pick_range_by_raycast: self.pick_range_by_raycast = Output.ArrayOfConfigAiRaycastConditionLengthU(self._io, self, self._root) if self.has_field_skill_anchor_range_min: self.skill_anchor_range_min = self._io.read_f4le() if self.has_field_skill_anchor_range_max: self.skill_anchor_range_max = self._io.read_f4le() if self.has_field_target_skill_anchor_range_min: self.target_skill_anchor_range_min = self._io.read_f4le() if self.has_field_target_skill_anchor_range_max: self.target_skill_anchor_range_max = self._io.read_f4le() if self.has_field_cast_range_type: self.cast_range_type = Output.EnumCondfigAiRangeType(self._io, self, self._root) if self.has_field_cast_range_min: self.cast_range_min = self._io.read_f4le() if self.has_field_cast_range_max: self.cast_range_max = self._io.read_f4le() if self.has_field_cast_range_xz_y: self.cast_range_xz_y = Output.ConfigAiCastRangeXzY(self._io, self, self._root) if self.has_field_global_values: self.global_values = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_global_values_logic_and: self.global_values_logic_and = self._io.read_u1() @property def has_field_skill_anchor_range_max(self): if hasattr(self, '_m_has_field_skill_anchor_range_max'): return self._m_has_field_skill_anchor_range_max self._m_has_field_skill_anchor_range_max = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_skill_anchor_range_max', None) @property def has_field_global_values_logic_and(self): if hasattr(self, '_m_has_field_global_values_logic_and'): return self._m_has_field_global_values_logic_and self._m_has_field_global_values_logic_and = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_global_values_logic_and', None) @property def has_field_cast_range_xz_y(self): if hasattr(self, '_m_has_field_cast_range_xz_y'): return self._m_has_field_cast_range_xz_y self._m_has_field_cast_range_xz_y = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_cast_range_xz_y', None) @property def has_field_pick_range_y_max(self): if hasattr(self, '_m_has_field_pick_range_y_max'): return self._m_has_field_pick_range_y_max self._m_has_field_pick_range_y_max = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_pick_range_y_max', None) @property def has_field_max_target_angle_y(self): if hasattr(self, '_m_has_field_max_target_angle_y'): return self._m_has_field_max_target_angle_y self._m_has_field_max_target_angle_y = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_max_target_angle_y', None) @property def has_field_max_target_angle_xz(self): if hasattr(self, '_m_has_field_max_target_angle_xz'): return self._m_has_field_max_target_angle_xz self._m_has_field_max_target_angle_xz = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_max_target_angle_xz', None) @property def has_field_pick_range_y_min(self): if hasattr(self, '_m_has_field_pick_range_y_min'): return self._m_has_field_pick_range_y_min self._m_has_field_pick_range_y_min = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_pick_range_y_min', None) @property def has_field_min_target_angle_y(self): if hasattr(self, '_m_has_field_min_target_angle_y'): return self._m_has_field_min_target_angle_y self._m_has_field_min_target_angle_y = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_min_target_angle_y', None) @property def has_field_target_skill_anchor_range_min(self): if hasattr(self, '_m_has_field_target_skill_anchor_range_min'): return self._m_has_field_target_skill_anchor_range_min self._m_has_field_target_skill_anchor_range_min = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_target_skill_anchor_range_min', None) @property def has_field_cast_range_type(self): if hasattr(self, '_m_has_field_cast_range_type'): return self._m_has_field_cast_range_type self._m_has_field_cast_range_type = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_cast_range_type', None) @property def has_field_need_re_init_cd(self): if hasattr(self, '_m_has_field_need_re_init_cd'): return self._m_has_field_need_re_init_cd self._m_has_field_need_re_init_cd = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_need_re_init_cd', None) @property def has_field_min_target_angle_xz(self): if hasattr(self, '_m_has_field_min_target_angle_xz'): return self._m_has_field_min_target_angle_xz self._m_has_field_min_target_angle_xz = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_min_target_angle_xz', None) @property def has_field_pick_range_min(self): if hasattr(self, '_m_has_field_pick_range_min'): return self._m_has_field_pick_range_min self._m_has_field_pick_range_min = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_pick_range_min', None) @property def has_field_skill_anchor_range_min(self): if hasattr(self, '_m_has_field_skill_anchor_range_min'): return self._m_has_field_skill_anchor_range_min self._m_has_field_skill_anchor_range_min = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_skill_anchor_range_min', None) @property def has_field_pick_range_max(self): if hasattr(self, '_m_has_field_pick_range_max'): return self._m_has_field_pick_range_max self._m_has_field_pick_range_max = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_pick_range_max', None) @property def has_field_target_skill_anchor_range_max(self): if hasattr(self, '_m_has_field_target_skill_anchor_range_max'): return self._m_has_field_target_skill_anchor_range_max self._m_has_field_target_skill_anchor_range_max = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_target_skill_anchor_range_max', None) @property def has_field_cast_range_max(self): if hasattr(self, '_m_has_field_cast_range_max'): return self._m_has_field_cast_range_max self._m_has_field_cast_range_max = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_cast_range_max', None) @property def has_field_global_values(self): if hasattr(self, '_m_has_field_global_values'): return self._m_has_field_global_values self._m_has_field_global_values = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_global_values', None) @property def has_field_pick_range_by_raycast(self): if hasattr(self, '_m_has_field_pick_range_by_raycast'): return self._m_has_field_pick_range_by_raycast self._m_has_field_pick_range_by_raycast = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_pick_range_by_raycast', None) @property def has_field_cast_range_min(self): if hasattr(self, '_m_has_field_cast_range_min'): return self._m_has_field_cast_range_min self._m_has_field_cast_range_min = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_cast_range_min', None) @property def has_field_pose(self): if hasattr(self, '_m_has_field_pose'): return self._m_has_field_pose self._m_has_field_pose = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_pose', None) class DictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root)) class EnumBitwiseOperator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BitwiseOperator, self.data.value) return getattr(self, '_m_value', None) class DispConfigGadgetPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigGadgetPredicate(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigPredicateByTime(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigPredicateByInteract(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigPredicateByPlatform(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class WeaponLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_required_exps: self.required_exps = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_required_exps(self): if hasattr(self, '_m_has_field_required_exps'): return self._m_has_field_required_exps self._m_has_field_required_exps = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_required_exps', None) class CaptureExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_capture_tag_config: self.capture_tag_config = Output.ArrayOfCaptureTagConfigLengthS(self._io, self, self._root) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_capture_tag_config(self): if hasattr(self, '_m_has_field_capture_tag_config'): return self._m_has_field_capture_tag_config self._m_has_field_capture_tag_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_capture_tag_config', None) class ConfigAnimatorMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_init_with_ground_hit_check: self.init_with_ground_hit_check = self._io.read_u1() if self.has_field_smoothed_speed: self.smoothed_speed = Output.ConfigMoveSmoothedSpeed(self._io, self, self._root) if self.has_field_move_on_ground: self.move_on_ground = self._io.read_u1() if self.has_field_move_on_water: self.move_on_water = self._io.read_u1() if self.has_field_move_on_water_depth: self.move_on_water_depth = self._io.read_f4le() if self.has_field_raycasts: self.raycasts = Output.ArrayOfConfigRaycastLengthU(self._io, self, self._root) if self.has_field_facing_move: self.facing_move = Output.EnumFacingMoveType(self._io, self, self._root) if self.has_field_air_facing_move: self.air_facing_move = Output.EnumFacingMoveType(self._io, self, self._root) if self.has_field_monster_size_type: self.monster_size_type = Output.EnumMonsterSizeType(self._io, self, self._root) if self.has_field_position_modify_state: self.position_modify_state = Output.EnumPositionModifyState(self._io, self, self._root) if self.has_field_position_modify_state_map: self.position_modify_state_map = Output.DictOfAuxTypesVlqBase128LeUEnumPositionModifyState(self._io, self, self._root) if self.has_field_destroy_rock_when_init: self.destroy_rock_when_init = self._io.read_u1() if self.has_field_yaw_speed_ratio: self.yaw_speed_ratio = self._io.read_f4le() if self.has_field_velocity_ratio: self.velocity_ratio = self._io.read_f4le() if self.has_field_launch_states: self.launch_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_land_states: self.land_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_position_modify_extra: self.position_modify_extra = self._io.read_u1() @property def has_field_move_on_water_depth(self): if hasattr(self, '_m_has_field_move_on_water_depth'): return self._m_has_field_move_on_water_depth self._m_has_field_move_on_water_depth = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_move_on_water_depth', None) @property def has_field_launch_states(self): if hasattr(self, '_m_has_field_launch_states'): return self._m_has_field_launch_states self._m_has_field_launch_states = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_launch_states', None) @property def has_field_smoothed_speed(self): if hasattr(self, '_m_has_field_smoothed_speed'): return self._m_has_field_smoothed_speed self._m_has_field_smoothed_speed = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_smoothed_speed', None) @property def has_field_yaw_speed_ratio(self): if hasattr(self, '_m_has_field_yaw_speed_ratio'): return self._m_has_field_yaw_speed_ratio self._m_has_field_yaw_speed_ratio = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_yaw_speed_ratio', None) @property def has_field_monster_size_type(self): if hasattr(self, '_m_has_field_monster_size_type'): return self._m_has_field_monster_size_type self._m_has_field_monster_size_type = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_monster_size_type', None) @property def has_field_move_on_ground(self): if hasattr(self, '_m_has_field_move_on_ground'): return self._m_has_field_move_on_ground self._m_has_field_move_on_ground = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_move_on_ground', None) @property def has_field_move_on_water(self): if hasattr(self, '_m_has_field_move_on_water'): return self._m_has_field_move_on_water self._m_has_field_move_on_water = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_move_on_water', None) @property def has_field_facing_move(self): if hasattr(self, '_m_has_field_facing_move'): return self._m_has_field_facing_move self._m_has_field_facing_move = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_facing_move', None) @property def has_field_position_modify_state(self): if hasattr(self, '_m_has_field_position_modify_state'): return self._m_has_field_position_modify_state self._m_has_field_position_modify_state = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_position_modify_state', None) @property def has_field_velocity_ratio(self): if hasattr(self, '_m_has_field_velocity_ratio'): return self._m_has_field_velocity_ratio self._m_has_field_velocity_ratio = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_velocity_ratio', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_land_states(self): if hasattr(self, '_m_has_field_land_states'): return self._m_has_field_land_states self._m_has_field_land_states = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_land_states', None) @property def has_field_raycasts(self): if hasattr(self, '_m_has_field_raycasts'): return self._m_has_field_raycasts self._m_has_field_raycasts = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_raycasts', None) @property def has_field_destroy_rock_when_init(self): if hasattr(self, '_m_has_field_destroy_rock_when_init'): return self._m_has_field_destroy_rock_when_init self._m_has_field_destroy_rock_when_init = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_destroy_rock_when_init', None) @property def has_field_air_facing_move(self): if hasattr(self, '_m_has_field_air_facing_move'): return self._m_has_field_air_facing_move self._m_has_field_air_facing_move = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_air_facing_move', None) @property def has_field_position_modify_state_map(self): if hasattr(self, '_m_has_field_position_modify_state_map'): return self._m_has_field_position_modify_state_map self._m_has_field_position_modify_state_map = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_position_modify_state_map', None) @property def has_field_position_modify_extra(self): if hasattr(self, '_m_has_field_position_modify_extra'): return self._m_has_field_position_modify_extra self._m_has_field_position_modify_extra = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_position_modify_extra', None) @property def has_field_init_with_ground_hit_check(self): if hasattr(self, '_m_has_field_init_with_ground_hit_check'): return self._m_has_field_init_with_ground_hit_check self._m_has_field_init_with_ground_hit_check = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_init_with_ground_hit_check', None) class ArrayOfPreviewActivityCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.PreviewActivityCond(self._io, self, self._root)) class ByTargetChargeValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element: self.element = Output.EnumElementType(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_element(self): if hasattr(self, '_m_has_field_element'): return self._m_has_field_element self._m_has_field_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_compare_type', None) class ShopTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = self._io.read_f4le() class AchievementExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_specials: self.ability_specials = Output.DictOfAuxTypesStringAuxTypesDynamicFloat(self._io, self, self._root) if self.has_field_force_use_self_current_attack_target: self.force_use_self_current_attack_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_force_use_self_current_attack_target(self): if hasattr(self, '_m_has_field_force_use_self_current_attack_target'): return self._m_has_field_force_use_self_current_attack_target self._m_has_field_force_use_self_current_attack_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_force_use_self_current_attack_target', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_ability_specials(self): if hasattr(self, '_m_has_field_ability_specials'): return self._m_has_field_ability_specials self._m_has_field_ability_specials = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_specials', None) class CheckboardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGadgetCameraBoxUiActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetCameraBoxUiActionType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeUFaceAnimationTSettingPathConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.FaceAnimationTSettingPathConfig(self._io, self, self._root) class EnvironmentWeightType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_animal_id: self.animal_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_alive_hour_map: self.alive_hour_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) @property def has_field_animal_id(self): if hasattr(self, '_m_has_field_animal_id'): return self._m_has_field_animal_id self._m_has_field_animal_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_animal_id', None) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_entity_type', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_alive_hour_map(self): if hasattr(self, '_m_has_field_alive_hour_map'): return self._m_has_field_alive_hour_map self._m_has_field_alive_hour_map = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_alive_hour_map', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiMeleeChargeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiMeleeChargeData(self._io, self, self._root) class ConfigRecordAnimatorInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_animator_parameter: self.animator_parameter = Output.AnimatorParameters(self._io, self, self._root) if self.has_field_current_state: self.current_state = Output.AnimatorRecordState(self._io, self, self._root) if self.has_field_next_state: self.next_state = Output.AnimatorRecordState(self._io, self, self._root) if self.has_field_transition_info: self.transition_info = Output.AnimatorRecordTransitionInfo(self._io, self, self._root) @property def has_field_animator_parameter(self): if hasattr(self, '_m_has_field_animator_parameter'): return self._m_has_field_animator_parameter self._m_has_field_animator_parameter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_animator_parameter', None) @property def has_field_current_state(self): if hasattr(self, '_m_has_field_current_state'): return self._m_has_field_current_state self._m_has_field_current_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_current_state', None) @property def has_field_next_state(self): if hasattr(self, '_m_has_field_next_state'): return self._m_has_field_next_state self._m_has_field_next_state = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_state', None) @property def has_field_transition_info(self): if hasattr(self, '_m_has_field_transition_info'): return self._m_has_field_transition_info self._m_has_field_transition_info = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_transition_info', None) class RemoveActorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBulletMoveAngleRotating(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMoveAngle(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_angular_velocity: self.angular_velocity = Output.Vector(self._io, self, self._root) @property def has_field_angular_velocity(self): if hasattr(self, '_m_has_field_angular_velocity'): return self._m_has_field_angular_velocity self._m_has_field_angular_velocity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angular_velocity', None) class KvpOfDictAuxTypesStringAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class ConfigClimateInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigClimateInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_temperature_options: self.temperature_options = Output.ConfigClimateTemperatureOptions(self._io, self, self._root) if self.has_field_climate_ui_info: self.climate_ui_info = Output.ConfigClimateUi(self._io, self, self._root) if self.has_field_climate_screen_eff_audio: self.climate_screen_eff_audio = Output.ConfigClimateAudio(self._io, self, self._root) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def has_field_temperature_options(self): if hasattr(self, '_m_has_field_temperature_options'): return self._m_has_field_temperature_options self._m_has_field_temperature_options = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_temperature_options', None) @property def has_field_climate_ui_info(self): if hasattr(self, '_m_has_field_climate_ui_info'): return self._m_has_field_climate_ui_info self._m_has_field_climate_ui_info = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_climate_ui_info', None) @property def has_field_climate_screen_eff_audio(self): if hasattr(self, '_m_has_field_climate_screen_eff_audio'): return self._m_has_field_climate_screen_eff_audio self._m_has_field_climate_screen_eff_audio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_climate_screen_eff_audio', None) class ConfigDirectionByDefault(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class ConfigBornByCollisionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class EnumRefreshType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RefreshType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesVlqBase128LeSConfigAiInvestigateData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiInvestigateData(self._io, self, self._root)) class DictOfEnumElementTypeDispConfigAbilityAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementTypeDispConfigAbilityAction(self._io, self, self._root)) class BlossomRefreshExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiFindBackData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFindBackData(self._io, self, self._root) class ArrayOfIdCountStrConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IdCountStrConfig(self._io, self, self._root)) class ConfigPlatformActionTokenChannel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_high_entity_types: self.high_entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_low_entity_types: self.low_entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_entity_type_token: self.entity_type_token = Output.DictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root) if self.has_field_default_cfg: self.default_cfg = Output.ConfigActionTokenChannelGroupInfo(self._io, self, self._root) if self.has_field_platform_cfg: self.platform_cfg = Output.DictOfAuxTypesStringConfigActionTokenChannelGroupInfo(self._io, self, self._root) if self.has_field_action_consume_token_limit: self.action_consume_token_limit = Output.DictOfEnumEntityTokenActionTypeAuxTypesVlqBase128LeS(self._io, self, self._root) @property def has_field_action_consume_token_limit(self): if hasattr(self, '_m_has_field_action_consume_token_limit'): return self._m_has_field_action_consume_token_limit self._m_has_field_action_consume_token_limit = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_action_consume_token_limit', None) @property def has_field_entity_type_token(self): if hasattr(self, '_m_has_field_entity_type_token'): return self._m_has_field_entity_type_token self._m_has_field_entity_type_token = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_entity_type_token', None) @property def has_field_low_entity_types(self): if hasattr(self, '_m_has_field_low_entity_types'): return self._m_has_field_low_entity_types self._m_has_field_low_entity_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_low_entity_types', None) @property def has_field_high_entity_types(self): if hasattr(self, '_m_has_field_high_entity_types'): return self._m_has_field_high_entity_types self._m_has_field_high_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_high_entity_types', None) @property def has_field_default_cfg(self): if hasattr(self, '_m_has_field_default_cfg'): return self._m_has_field_default_cfg self._m_has_field_default_cfg = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_cfg', None) @property def has_field_platform_cfg(self): if hasattr(self, '_m_has_field_platform_cfg'): return self._m_has_field_platform_cfg self._m_has_field_platform_cfg = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_platform_cfg', None) class GuideLongPressTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigCutsceneContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigCutsceneContext(self._io, self, self._root)) class FurnitureMakeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumShopPrecondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopPrecondition, self.data.value) return getattr(self, '_m_value', None) class ReviveDeadAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ReviveAvatar(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_revive_other_player_avatar: self.is_revive_other_player_avatar = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_ratio: self.cd_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_range: self.range = self._io.read_f4le() @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_range', None) @property def amount_by_target_max_hp_ratio(self): if hasattr(self, '_m_amount_by_target_max_hp_ratio'): return self._m_amount_by_target_max_hp_ratio self._m_amount_by_target_max_hp_ratio = self.base.amount_by_target_max_hp_ratio return getattr(self, '_m_amount_by_target_max_hp_ratio', None) @property def mute_heal_effect(self): if hasattr(self, '_m_mute_heal_effect'): return self._m_mute_heal_effect self._m_mute_heal_effect = self.base.mute_heal_effect return getattr(self, '_m_mute_heal_effect', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_revive_other_player_avatar(self): if hasattr(self, '_m_has_field_is_revive_other_player_avatar'): return self._m_has_field_is_revive_other_player_avatar self._m_has_field_is_revive_other_player_avatar = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_revive_other_player_avatar', None) @property def ignore_ability_property(self): if hasattr(self, '_m_ignore_ability_property'): return self._m_ignore_ability_property self._m_ignore_ability_property = self.base.ignore_ability_property return getattr(self, '_m_ignore_ability_property', None) @property def amount(self): if hasattr(self, '_m_amount'): return self._m_amount self._m_amount = self.base.amount return getattr(self, '_m_amount', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def heal_ratio(self): if hasattr(self, '_m_heal_ratio'): return self._m_heal_ratio self._m_heal_ratio = self.base.heal_ratio return getattr(self, '_m_heal_ratio', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def amount_by_caster_attack_ratio(self): if hasattr(self, '_m_amount_by_caster_attack_ratio'): return self._m_amount_by_caster_attack_ratio self._m_amount_by_caster_attack_ratio = self.base.amount_by_caster_attack_ratio return getattr(self, '_m_amount_by_caster_attack_ratio', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def amount_by_caster_max_hp_ratio(self): if hasattr(self, '_m_amount_by_caster_max_hp_ratio'): return self._m_amount_by_caster_max_hp_ratio self._m_amount_by_caster_max_hp_ratio = self.base.amount_by_caster_max_hp_ratio return getattr(self, '_m_amount_by_caster_max_hp_ratio', None) @property def amount_by_target_current_hp_ratio(self): if hasattr(self, '_m_amount_by_target_current_hp_ratio'): return self._m_amount_by_target_current_hp_ratio self._m_amount_by_target_current_hp_ratio = self.base.amount_by_target_current_hp_ratio return getattr(self, '_m_amount_by_target_current_hp_ratio', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class TrialFetterConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringDispContextCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispContextCondition(self._io, self, self._root) class FaceAnimationTSettingPathConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_path: self.path = AuxTypes.String(self._io, self, self._root) @property def has_field_path(self): if hasattr(self, '_m_has_field_path'): return self._m_has_field_path self._m_has_field_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_path', None) class CopyGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_src_target: self.src_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_dst_target: self.dst_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_src_key: self.src_key = AuxTypes.String(self._io, self, self._root) if self.has_field_dst_key: self.dst_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_src_key(self): if hasattr(self, '_m_has_field_src_key'): return self._m_has_field_src_key self._m_has_field_src_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_src_key', None) @property def has_field_dst_target(self): if hasattr(self, '_m_has_field_dst_target'): return self._m_has_field_dst_target self._m_has_field_dst_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dst_target', None) @property def has_field_dst_key(self): if hasattr(self, '_m_has_field_dst_key'): return self._m_has_field_dst_key self._m_has_field_dst_key = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_dst_key', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_src_target(self): if hasattr(self, '_m_has_field_src_target'): return self._m_has_field_src_target self._m_has_field_src_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_src_target', None) class EnumEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EffectType, self.data.value) return getattr(self, '_m_value', None) class AttachToNormalizedTimeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_id: self.state_id = AuxTypes.String(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_normalize_start: self.normalize_start = self._io.read_f4le() if self.has_field_normalize_end: self.normalize_end = self._io.read_f4le() @property def has_field_state_id(self): if hasattr(self, '_m_has_field_state_id'): return self._m_has_field_state_id self._m_has_field_state_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_id', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_normalize_end(self): if hasattr(self, '_m_has_field_normalize_end'): return self._m_has_field_normalize_end self._m_has_field_normalize_end = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_normalize_end', None) @property def has_field_normalize_start(self): if hasattr(self, '_m_has_field_normalize_start'): return self._m_has_field_normalize_start self._m_has_field_normalize_start = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_normalize_start', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesStringAuxTypesDynamicArgument(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAuxTypesDynamicArgument(self._io, self, self._root)) class TrialFetterConditionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumTrialFetterConditionType(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_list', None) class SectrBakeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_obj_type: self.obj_type = Output.EnumSectrObjectType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_obj_type(self): if hasattr(self, '_m_has_field_obj_type'): return self._m_has_field_obj_type self._m_has_field_obj_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_obj_type', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_id', None) class EnumCanBeModifiedBy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CanBeModifiedBy, self.data.value) return getattr(self, '_m_value', None) class SelectActionPointByAwayFromAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class BoredCreateMonsterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdGroupColliderInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_spawn_position: self.spawn_position = Output.Vector(self._io, self, self._root) if self.has_field_spawn_face_fwd: self.spawn_face_fwd = Output.Vector(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_spawn_position(self): if hasattr(self, '_m_has_field_spawn_position'): return self._m_has_field_spawn_position self._m_has_field_spawn_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_spawn_position', None) @property def has_field_spawn_face_fwd(self): if hasattr(self, '_m_has_field_spawn_face_fwd'): return self._m_has_field_spawn_face_fwd self._m_has_field_spawn_face_fwd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_face_fwd', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_radius', None) class KvpOfDictAuxTypesStringConfigPublicAiSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPublicAiSkillCd(self._io, self, self._root) class QuestCondCompareTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActCameraRadialBlur(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_radial_blur: self.camera_radial_blur = Output.ConfigCameraRadialBlur(self._io, self, self._root) @property def has_field_camera_radial_blur(self): if hasattr(self, '_m_has_field_camera_radial_blur'): return self._m_has_field_camera_radial_blur self._m_has_field_camera_radial_blur = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_radial_blur', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfWatcherPredicateConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.WatcherPredicateConfig(self._io, self, self._root)) class EnumBodyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BodyType, self.data.value) return getattr(self, '_m_value', None) class EnumSelectTargetDefaultType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SelectTargetDefaultType, self.data.value) return getattr(self, '_m_value', None) class GeneralRoutineTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAiSkillCdMultiplier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_multiplier: self.multiplier = self._io.read_f4le() @property def has_field_multiplier(self): if hasattr(self, '_m_has_field_multiplier'): return self._m_has_field_multiplier self._m_has_field_multiplier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_multiplier', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DispConfigAudioOperation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigAudioOperation(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigAudioEventOnEffectOp(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigAudioPositionedEmitterOp(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigAudioEventOp(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigAudioPositionedOp(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigAudioPositionedEventOp(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigAudioEmitterOp(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ClearGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DispConfigBaseShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseShape(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigShapePolygon(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigShapeCube(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigShapeCircle(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigShapeSector(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigShapeSphere(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigShapeRect(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ArrayOfConfigWwiseStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigWwiseString(self._io, self, self._root)) class StateCameraTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ResetAiThreatBroadcastRange(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_range: self.range = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_range', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class WorldAreaExploreEventConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_event_id: self.event_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_event_type: self.event_type = Output.EnumExploreEventType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_explore_weight: self.explore_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_explore_weight(self): if hasattr(self, '_m_has_field_explore_weight'): return self._m_has_field_explore_weight self._m_has_field_explore_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_explore_weight', None) @property def has_field_event_type(self): if hasattr(self, '_m_has_field_event_type'): return self._m_has_field_event_type self._m_has_field_event_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_event_type', None) @property def has_field_event_id(self): if hasattr(self, '_m_has_field_event_id'): return self._m_has_field_event_id self._m_has_field_event_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_event_id', None) class EnumCoopCgType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopCgType, self.data.value) return getattr(self, '_m_value', None) class ActivitySkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EffigyLimitingConditionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BaseAbilityLogic(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_local_id: self.local_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_local_id(self): if hasattr(self, '_m_has_field_local_id'): return self._m_has_field_local_id self._m_has_field_local_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_local_id', None) class TreasureMapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumTdPlayTowerTypeConfigTdPlayTowerData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumTdPlayTowerType(self._io, self, self._root) self.value = Output.ConfigTdPlayTowerData(self._io, self, self._root) class MonsterSpecialNameExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_special_name_id: self.special_name_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_name_lab_id: self.special_name_lab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_name: self.special_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_in_random_list: self.is_in_random_list = self._io.read_u1() @property def has_field_special_name_id(self): if hasattr(self, '_m_has_field_special_name_id'): return self._m_has_field_special_name_id self._m_has_field_special_name_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_special_name_id', None) @property def has_field_special_name_lab_id(self): if hasattr(self, '_m_has_field_special_name_lab_id'): return self._m_has_field_special_name_lab_id self._m_has_field_special_name_lab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_special_name_lab_id', None) @property def has_field_special_name(self): if hasattr(self, '_m_has_field_special_name'): return self._m_has_field_special_name self._m_has_field_special_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_special_name', None) @property def has_field_is_in_random_list(self): if hasattr(self, '_m_has_field_is_in_random_list'): return self._m_has_field_is_in_random_list self._m_has_field_is_in_random_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_in_random_list', None) class AttachToPoseIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pose_i_ds: self.pose_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_pose_i_ds(self): if hasattr(self, '_m_has_field_pose_i_ds'): return self._m_has_field_pose_i_ds self._m_has_field_pose_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pose_i_ds', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class LoadingTipsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfGlobalValuePairLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.GlobalValuePair(self._io, self, self._root)) class EnumTalentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalentType, self.data.value) return getattr(self, '_m_value', None) class ShakeByAinmator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_shake_flag: self.shake_flag = self._io.read_f4le() if self.has_field_hit_box_names: self.hit_box_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_shake_flag(self): if hasattr(self, '_m_has_field_shake_flag'): return self._m_has_field_shake_flag self._m_has_field_shake_flag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shake_flag', None) @property def has_field_hit_box_names(self): if hasattr(self, '_m_has_field_hit_box_names'): return self._m_has_field_hit_box_names self._m_has_field_hit_box_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hit_box_names', None) class ConfigSitOrStandAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_sit: self.is_sit = self._io.read_u1() if self.has_field_stand_direction: self.stand_direction = Output.EnumStandDirection(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_is_sit(self): if hasattr(self, '_m_has_field_is_sit'): return self._m_has_field_is_sit self._m_has_field_is_sit = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_sit', None) @property def has_field_stand_direction(self): if hasattr(self, '_m_has_field_stand_direction'): return self._m_has_field_stand_direction self._m_has_field_stand_direction = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stand_direction', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class KvpOfDictAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigJob(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.DictOfAuxTypesVlqBase128LeSConfigJob(self._io, self, self._root) class DailyTaskRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_vec: self.drop_vec = Output.ArrayOfDailyTaskDropConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_drop_vec(self): if hasattr(self, '_m_has_field_drop_vec'): return self._m_has_field_drop_vec self._m_has_field_drop_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_drop_vec', None) class RegionSearchRegionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActivityGachaTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGachaTargetType, self.data.value) return getattr(self, '_m_value', None) class BlossomGroupsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_section_id: self.section_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_type_vec: self.refresh_type_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_new_group_vec: self.new_group_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_decorate_group_vec: self.decorate_group_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_next_camp_id_vec: self.next_camp_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_safe: self.is_safe = self._io.read_u1() if self.has_field_is_initial_refresh: self.is_initial_refresh = self._io.read_u1() if self.has_field_finish_progress: self.finish_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_level: self.limit_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fight_radius: self.fight_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_remind_radius: self.remind_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_blossom_tips: self.blossom_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delay_unload_sec: self.delay_unload_sec = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_blossom_tips(self): if hasattr(self, '_m_has_field_blossom_tips'): return self._m_has_field_blossom_tips self._m_has_field_blossom_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_blossom_tips', None) @property def has_field_delay_unload_sec(self): if hasattr(self, '_m_has_field_delay_unload_sec'): return self._m_has_field_delay_unload_sec self._m_has_field_delay_unload_sec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_delay_unload_sec', None) @property def has_field_finish_progress(self): if hasattr(self, '_m_has_field_finish_progress'): return self._m_has_field_finish_progress self._m_has_field_finish_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_finish_progress', None) @property def has_field_new_group_vec(self): if hasattr(self, '_m_has_field_new_group_vec'): return self._m_has_field_new_group_vec self._m_has_field_new_group_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_new_group_vec', None) @property def has_field_decorate_group_vec(self): if hasattr(self, '_m_has_field_decorate_group_vec'): return self._m_has_field_decorate_group_vec self._m_has_field_decorate_group_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_decorate_group_vec', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_next_camp_id_vec(self): if hasattr(self, '_m_has_field_next_camp_id_vec'): return self._m_has_field_next_camp_id_vec self._m_has_field_next_camp_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_next_camp_id_vec', None) @property def has_field_refresh_type_vec(self): if hasattr(self, '_m_has_field_refresh_type_vec'): return self._m_has_field_refresh_type_vec self._m_has_field_refresh_type_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_refresh_type_vec', None) @property def has_field_fight_radius(self): if hasattr(self, '_m_has_field_fight_radius'): return self._m_has_field_fight_radius self._m_has_field_fight_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_fight_radius', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_section_id(self): if hasattr(self, '_m_has_field_section_id'): return self._m_has_field_section_id self._m_has_field_section_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_section_id', None) @property def has_field_is_safe(self): if hasattr(self, '_m_has_field_is_safe'): return self._m_has_field_is_safe self._m_has_field_is_safe = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_safe', None) @property def has_field_limit_level(self): if hasattr(self, '_m_has_field_limit_level'): return self._m_has_field_limit_level self._m_has_field_limit_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_limit_level', None) @property def has_field_remind_radius(self): if hasattr(self, '_m_has_field_remind_radius'): return self._m_has_field_remind_radius self._m_has_field_remind_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_remind_radius', None) @property def has_field_is_initial_refresh(self): if hasattr(self, '_m_has_field_is_initial_refresh'): return self._m_has_field_is_initial_refresh self._m_has_field_is_initial_refresh = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_initial_refresh', None) class SetPaimonTempOffset(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_: self.from_ = Output.EnumPaimonRequestFrom(self._io, self, self._root) if self.has_field_off_set_pos: self.off_set_pos = Output.Vector(self._io, self, self._root) if self.has_field_time: self.time = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_from_(self): if hasattr(self, '_m_has_field_from_'): return self._m_has_field_from_ self._m_has_field_from_ = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_', None) @property def has_field_off_set_pos(self): if hasattr(self, '_m_has_field_off_set_pos'): return self._m_has_field_off_set_pos self._m_has_field_off_set_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_off_set_pos', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_time', None) class DailyTaskLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldAreaComfortExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_type: self.area_type = Output.EnumHomeWorldAreaType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_comfort: self.max_comfort = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_safe_point_str: self.safe_point_str = AuxTypes.String(self._io, self, self._root) if self.has_field_low_load_limit: self.low_load_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_middle_load_limit: self.middle_load_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_high_load_limit: self.high_load_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_center_pos: self.area_center_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_area_center_rot: self.area_center_rot = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_area_center_rot(self): if hasattr(self, '_m_has_field_area_center_rot'): return self._m_has_field_area_center_rot self._m_has_field_area_center_rot = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_area_center_rot', None) @property def has_field_high_load_limit(self): if hasattr(self, '_m_has_field_high_load_limit'): return self._m_has_field_high_load_limit self._m_has_field_high_load_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_high_load_limit', None) @property def has_field_middle_load_limit(self): if hasattr(self, '_m_has_field_middle_load_limit'): return self._m_has_field_middle_load_limit self._m_has_field_middle_load_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_middle_load_limit', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_area_type(self): if hasattr(self, '_m_has_field_area_type'): return self._m_has_field_area_type self._m_has_field_area_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_area_type', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_max_comfort(self): if hasattr(self, '_m_has_field_max_comfort'): return self._m_has_field_max_comfort self._m_has_field_max_comfort = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_max_comfort', None) @property def has_field_area_center_pos(self): if hasattr(self, '_m_has_field_area_center_pos'): return self._m_has_field_area_center_pos self._m_has_field_area_center_pos = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_area_center_pos', None) @property def has_field_safe_point_str(self): if hasattr(self, '_m_has_field_safe_point_str'): return self._m_has_field_safe_point_str self._m_has_field_safe_point_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_safe_point_str', None) @property def has_field_low_load_limit(self): if hasattr(self, '_m_has_field_low_load_limit'): return self._m_has_field_low_load_limit self._m_has_field_low_load_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_low_load_limit', None) class HomeWorldBgmExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_bgm_id: self.bgm_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_unlock: self.is_default_unlock = self._io.read_u1() if self.has_field_is_room_scene_usable: self.is_room_scene_usable = self._io.read_u1() if self.has_field_is_world_scene_usable: self.is_world_scene_usable = self._io.read_u1() if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bgm_path: self.bgm_path = AuxTypes.String(self._io, self, self._root) if self.has_field_bgm_name: self.bgm_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bgm_id(self): if hasattr(self, '_m_has_field_bgm_id'): return self._m_has_field_bgm_id self._m_has_field_bgm_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_bgm_id', None) @property def has_field_bgm_name(self): if hasattr(self, '_m_has_field_bgm_name'): return self._m_has_field_bgm_name self._m_has_field_bgm_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_bgm_name', None) @property def has_field_bgm_path(self): if hasattr(self, '_m_has_field_bgm_path'): return self._m_has_field_bgm_path self._m_has_field_bgm_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_bgm_path', None) @property def has_field_is_room_scene_usable(self): if hasattr(self, '_m_has_field_is_room_scene_usable'): return self._m_has_field_is_room_scene_usable self._m_has_field_is_room_scene_usable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_room_scene_usable', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_is_default_unlock(self): if hasattr(self, '_m_has_field_is_default_unlock'): return self._m_has_field_is_default_unlock self._m_has_field_is_default_unlock = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_default_unlock', None) @property def has_field_is_world_scene_usable(self): if hasattr(self, '_m_has_field_is_world_scene_usable'): return self._m_has_field_is_world_scene_usable self._m_has_field_is_world_scene_usable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_world_scene_usable', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_sort_order', None) class ConfigNpcOtherDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class IrodoriChessCardNumericalModificationModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUAdaptiveParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.AdaptiveParam(self._io, self, self._root) class ConfigHeadControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_use_head_control: self.use_head_control = self._io.read_u1() if self.has_field_max_yaw_degree: self.max_yaw_degree = self._io.read_f4le() if self.has_field_max_pitch_degree: self.max_pitch_degree = self._io.read_f4le() if self.has_field_speed: self.speed = self._io.read_f4le() if self.has_field_weight_speed: self.weight_speed = self._io.read_f4le() if self.has_field_use_white_anim_states: self.use_white_anim_states = self._io.read_u1() if self.has_field_anim_states: self.anim_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_dont_anim_states: self.dont_anim_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_speed(self): if hasattr(self, '_m_has_field_speed'): return self._m_has_field_speed self._m_has_field_speed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_speed', None) @property def has_field_weight_speed(self): if hasattr(self, '_m_has_field_weight_speed'): return self._m_has_field_weight_speed self._m_has_field_weight_speed = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_weight_speed', None) @property def has_field_max_yaw_degree(self): if hasattr(self, '_m_has_field_max_yaw_degree'): return self._m_has_field_max_yaw_degree self._m_has_field_max_yaw_degree = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_yaw_degree', None) @property def has_field_use_head_control(self): if hasattr(self, '_m_has_field_use_head_control'): return self._m_has_field_use_head_control self._m_has_field_use_head_control = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_head_control', None) @property def has_field_dont_anim_states(self): if hasattr(self, '_m_has_field_dont_anim_states'): return self._m_has_field_dont_anim_states self._m_has_field_dont_anim_states = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_dont_anim_states', None) @property def has_field_anim_states(self): if hasattr(self, '_m_has_field_anim_states'): return self._m_has_field_anim_states self._m_has_field_anim_states = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_anim_states', None) @property def has_field_use_white_anim_states(self): if hasattr(self, '_m_has_field_use_white_anim_states'): return self._m_has_field_use_white_anim_states self._m_has_field_use_white_anim_states = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_use_white_anim_states', None) @property def has_field_max_pitch_degree(self): if hasattr(self, '_m_has_field_max_pitch_degree'): return self._m_has_field_max_pitch_degree self._m_has_field_max_pitch_degree = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_pitch_degree', None) class MpPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialAdjustData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSpacialAdjustData(self._io, self, self._root) class KvpOfDictAuxTypesStringConfigPerfGradeItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfGradeItemOptionArrayInfo(self._io, self, self._root) class KvpOfDictAuxTypesStringConfigMonsterInitialPose(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigMonsterInitialPose(self._io, self, self._root) class KvpOfDictEnumPerfCostRatioGradeF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPerfCostRatioGrade(self._io, self, self._root) self.value = self._io.read_f4le() class InvestigationMonsterConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBaseStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseStateIdInfo(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigNpcStateIdInfo(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigNormalStateIdInfo(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigMonsterStateIdInfo(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigAvatarStateIdInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class RocketJumpTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityStateResistanceByIdExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MassiveElementTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetStateFireAiSound(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_volume: self.volume = self._io.read_f4le() @property def has_field_volume(self): if hasattr(self, '_m_has_field_volume'): return self._m_has_field_volume self._m_has_field_volume = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_volume', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class AddActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestState, self.data.value) return getattr(self, '_m_value', None) class EnumGuidePlatformType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuidePlatformType, self.data.value) return getattr(self, '_m_value', None) class ActionPanelEffectSlotComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EquipSizeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_equip_type: self.equip_type = Output.EnumEquipEntityType(self._io, self, self._root) if self.has_field_put_away_size: self.put_away_size = self._io.read_f4le() if self.has_field_take_out_size: self.take_out_size = self._io.read_f4le() @property def has_field_equip_type(self): if hasattr(self, '_m_has_field_equip_type'): return self._m_has_field_equip_type self._m_has_field_equip_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip_type', None) @property def has_field_put_away_size(self): if hasattr(self, '_m_has_field_put_away_size'): return self._m_has_field_put_away_size self._m_has_field_put_away_size = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_put_away_size', None) @property def has_field_take_out_size(self): if hasattr(self, '_m_has_field_take_out_size'): return self._m_has_field_take_out_size self._m_has_field_take_out_size = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_take_out_size', None) class ConfigAvatarSpeech(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suitable_equip_obtain: self.suitable_equip_obtain = Output.ArrayOfAvatarSpeechEquipObtainLengthU(self._io, self, self._root) if self.has_field_unsuitable_equip_obtain: self.unsuitable_equip_obtain = Output.ArrayOfAvatarSpeechEquipObtainLengthU(self._io, self, self._root) if self.has_field_event_common_prefix: self.event_common_prefix = AuxTypes.String(self._io, self, self._root) if self.has_field_external_voice_event: self.external_voice_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_person_switch_key: self.person_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_positioning_switch_key: self.positioning_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_initial_delay_rtpc: self.initial_delay_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_person_switch_value_map: self.person_switch_value_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_positioning_switch_value_map: self.positioning_switch_value_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_external_sound_names: self.external_sound_names = Output.ArrayOfVoiceSoundLengthU(self._io, self, self._root) if self.has_field_default_narration_interval: self.default_narration_interval = self._io.read_f4le() if self.has_field_default_narration_duration: self.default_narration_duration = self._io.read_f4le() if self.has_field_default_narration_max_duration: self.default_narration_max_duration = self._io.read_f4le() if self.has_field_gacha_voice_trigger_param: self.gacha_voice_trigger_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_join_team_voice_trigger_param: self.join_team_voice_trigger_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_voice_trigger_map: self.fetter_voice_trigger_map = Output.DictOfAuxTypesVlqBase128LeUVoiceTriggerIdentity(self._io, self, self._root) if self.has_field_teammate_low_hp_vo_hp_ratio: self.teammate_low_hp_vo_hp_ratio = self._io.read_f4le() if self.has_field_teammate_low_hp_vo_cooldown: self.teammate_low_hp_vo_cooldown = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_teammate_low_hp_vo_vo_trigger: self.teammate_low_hp_vo_vo_trigger = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_teammate_low_hp_vo_distance: self.teammate_low_hp_vo_distance = self._io.read_f4le() if self.has_field_teammate_low_hp_vo_hp_desc_ratio: self.teammate_low_hp_vo_hp_desc_ratio = self._io.read_f4le() if self.has_field_teammate_low_hp_vo_distance_map: self.teammate_low_hp_vo_distance_map = Output.DictOfAuxTypesVlqBase128LeUF4(self._io, self, self._root) if self.has_field_local_player_low_hp_vo_hp_ratio: self.local_player_low_hp_vo_hp_ratio = self._io.read_f4le() if self.has_field_local_player_low_hp_vo_cooldown: self.local_player_low_hp_vo_cooldown = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_local_player_low_hp_vo_vo_trigger: self.local_player_low_hp_vo_vo_trigger = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_promotion_voice_trigger_map: self.promotion_voice_trigger_map = Output.DictOfAuxTypesVlqBase128LeUVoiceTriggerIdentity(self._io, self, self._root) if self.has_field_open_chest_vo_trigger: self.open_chest_vo_trigger = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_voice_black_list: self.voice_black_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_open_chest_vo_trigger(self): if hasattr(self, '_m_has_field_open_chest_vo_trigger'): return self._m_has_field_open_chest_vo_trigger self._m_has_field_open_chest_vo_trigger = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_open_chest_vo_trigger', None) @property def has_field_teammate_low_hp_vo_hp_desc_ratio(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_hp_desc_ratio'): return self._m_has_field_teammate_low_hp_vo_hp_desc_ratio self._m_has_field_teammate_low_hp_vo_hp_desc_ratio = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_hp_desc_ratio', None) @property def has_field_default_narration_duration(self): if hasattr(self, '_m_has_field_default_narration_duration'): return self._m_has_field_default_narration_duration self._m_has_field_default_narration_duration = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_default_narration_duration', None) @property def has_field_external_voice_event(self): if hasattr(self, '_m_has_field_external_voice_event'): return self._m_has_field_external_voice_event self._m_has_field_external_voice_event = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_external_voice_event', None) @property def has_field_teammate_low_hp_vo_distance(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_distance'): return self._m_has_field_teammate_low_hp_vo_distance self._m_has_field_teammate_low_hp_vo_distance = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_distance', None) @property def has_field_external_sound_names(self): if hasattr(self, '_m_has_field_external_sound_names'): return self._m_has_field_external_sound_names self._m_has_field_external_sound_names = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_external_sound_names', None) @property def has_field_positioning_switch_key(self): if hasattr(self, '_m_has_field_positioning_switch_key'): return self._m_has_field_positioning_switch_key self._m_has_field_positioning_switch_key = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_positioning_switch_key', None) @property def has_field_default_narration_interval(self): if hasattr(self, '_m_has_field_default_narration_interval'): return self._m_has_field_default_narration_interval self._m_has_field_default_narration_interval = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_default_narration_interval', None) @property def has_field_person_switch_value_map(self): if hasattr(self, '_m_has_field_person_switch_value_map'): return self._m_has_field_person_switch_value_map self._m_has_field_person_switch_value_map = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_person_switch_value_map', None) @property def has_field_join_team_voice_trigger_param(self): if hasattr(self, '_m_has_field_join_team_voice_trigger_param'): return self._m_has_field_join_team_voice_trigger_param self._m_has_field_join_team_voice_trigger_param = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_join_team_voice_trigger_param', None) @property def has_field_event_common_prefix(self): if hasattr(self, '_m_has_field_event_common_prefix'): return self._m_has_field_event_common_prefix self._m_has_field_event_common_prefix = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_event_common_prefix', None) @property def has_field_teammate_low_hp_vo_distance_map(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_distance_map'): return self._m_has_field_teammate_low_hp_vo_distance_map self._m_has_field_teammate_low_hp_vo_distance_map = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_distance_map', None) @property def has_field_teammate_low_hp_vo_hp_ratio(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_hp_ratio'): return self._m_has_field_teammate_low_hp_vo_hp_ratio self._m_has_field_teammate_low_hp_vo_hp_ratio = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_hp_ratio', None) @property def has_field_local_player_low_hp_vo_vo_trigger(self): if hasattr(self, '_m_has_field_local_player_low_hp_vo_vo_trigger'): return self._m_has_field_local_player_low_hp_vo_vo_trigger self._m_has_field_local_player_low_hp_vo_vo_trigger = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_local_player_low_hp_vo_vo_trigger', None) @property def has_field_teammate_low_hp_vo_cooldown(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_cooldown'): return self._m_has_field_teammate_low_hp_vo_cooldown self._m_has_field_teammate_low_hp_vo_cooldown = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_cooldown', None) @property def has_field_fetter_voice_trigger_map(self): if hasattr(self, '_m_has_field_fetter_voice_trigger_map'): return self._m_has_field_fetter_voice_trigger_map self._m_has_field_fetter_voice_trigger_map = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_fetter_voice_trigger_map', None) @property def has_field_gacha_voice_trigger_param(self): if hasattr(self, '_m_has_field_gacha_voice_trigger_param'): return self._m_has_field_gacha_voice_trigger_param self._m_has_field_gacha_voice_trigger_param = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_gacha_voice_trigger_param', None) @property def has_field_suitable_equip_obtain(self): if hasattr(self, '_m_has_field_suitable_equip_obtain'): return self._m_has_field_suitable_equip_obtain self._m_has_field_suitable_equip_obtain = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_suitable_equip_obtain', None) @property def has_field_voice_black_list(self): if hasattr(self, '_m_has_field_voice_black_list'): return self._m_has_field_voice_black_list self._m_has_field_voice_black_list = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_voice_black_list', None) @property def has_field_default_narration_max_duration(self): if hasattr(self, '_m_has_field_default_narration_max_duration'): return self._m_has_field_default_narration_max_duration self._m_has_field_default_narration_max_duration = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_default_narration_max_duration', None) @property def has_field_initial_delay_rtpc(self): if hasattr(self, '_m_has_field_initial_delay_rtpc'): return self._m_has_field_initial_delay_rtpc self._m_has_field_initial_delay_rtpc = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_initial_delay_rtpc', None) @property def has_field_local_player_low_hp_vo_cooldown(self): if hasattr(self, '_m_has_field_local_player_low_hp_vo_cooldown'): return self._m_has_field_local_player_low_hp_vo_cooldown self._m_has_field_local_player_low_hp_vo_cooldown = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_local_player_low_hp_vo_cooldown', None) @property def has_field_unsuitable_equip_obtain(self): if hasattr(self, '_m_has_field_unsuitable_equip_obtain'): return self._m_has_field_unsuitable_equip_obtain self._m_has_field_unsuitable_equip_obtain = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_unsuitable_equip_obtain', None) @property def has_field_teammate_low_hp_vo_vo_trigger(self): if hasattr(self, '_m_has_field_teammate_low_hp_vo_vo_trigger'): return self._m_has_field_teammate_low_hp_vo_vo_trigger self._m_has_field_teammate_low_hp_vo_vo_trigger = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_teammate_low_hp_vo_vo_trigger', None) @property def has_field_local_player_low_hp_vo_hp_ratio(self): if hasattr(self, '_m_has_field_local_player_low_hp_vo_hp_ratio'): return self._m_has_field_local_player_low_hp_vo_hp_ratio self._m_has_field_local_player_low_hp_vo_hp_ratio = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_local_player_low_hp_vo_hp_ratio', None) @property def has_field_promotion_voice_trigger_map(self): if hasattr(self, '_m_has_field_promotion_voice_trigger_map'): return self._m_has_field_promotion_voice_trigger_map self._m_has_field_promotion_voice_trigger_map = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_promotion_voice_trigger_map', None) @property def has_field_positioning_switch_value_map(self): if hasattr(self, '_m_has_field_positioning_switch_value_map'): return self._m_has_field_positioning_switch_value_map self._m_has_field_positioning_switch_value_map = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_positioning_switch_value_map', None) @property def has_field_person_switch_key(self): if hasattr(self, '_m_has_field_person_switch_key'): return self._m_has_field_person_switch_key self._m_has_field_person_switch_key = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_person_switch_key', None) class HitLevelTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfNumberItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberItem(self._io, self, self._root) class WinterCampExploreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_groups: self.drop_groups = Output.ArrayOfWinterCampDropGroupLengthS(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_drop_groups(self): if hasattr(self, '_m_has_field_drop_groups'): return self._m_has_field_drop_groups self._m_has_field_drop_groups = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_drop_groups', None) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) class ArrayOfPoint2dLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.Point2d(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) class ChestLevelSetConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_zone_min_level: self.zone_min_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chest_level: self.chest_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_zone_min_level(self): if hasattr(self, '_m_has_field_zone_min_level'): return self._m_has_field_zone_min_level self._m_has_field_zone_min_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_zone_min_level', None) @property def has_field_chest_level(self): if hasattr(self, '_m_has_field_chest_level'): return self._m_has_field_chest_level self._m_has_field_chest_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chest_level', None) class ConfigControlPartByIk(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigControlPart(self._io, self, self._root) @property def forward_by_trans_name(self): if hasattr(self, '_m_forward_by_trans_name'): return self._m_forward_by_trans_name self._m_forward_by_trans_name = self.base.forward_by_trans_name return getattr(self, '_m_forward_by_trans_name', None) @property def forward_by(self): if hasattr(self, '_m_forward_by'): return self._m_forward_by self._m_forward_by = self.base.forward_by return getattr(self, '_m_forward_by', None) @property def rotate_by(self): if hasattr(self, '_m_rotate_by'): return self._m_rotate_by self._m_rotate_by = self.base.rotate_by return getattr(self, '_m_rotate_by', None) @property def forward_axial_fix(self): if hasattr(self, '_m_forward_axial_fix'): return self._m_forward_axial_fix self._m_forward_axial_fix = self.base.forward_axial_fix return getattr(self, '_m_forward_axial_fix', None) @property def do_on_un_eabled(self): if hasattr(self, '_m_do_on_un_eabled'): return self._m_do_on_un_eabled self._m_do_on_un_eabled = self.base.do_on_un_eabled return getattr(self, '_m_do_on_un_eabled', None) @property def limit_vertical(self): if hasattr(self, '_m_limit_vertical'): return self._m_limit_vertical self._m_limit_vertical = self.base.limit_vertical return getattr(self, '_m_limit_vertical', None) @property def limit_horizontal(self): if hasattr(self, '_m_limit_horizontal'): return self._m_limit_horizontal self._m_limit_horizontal = self.base.limit_horizontal return getattr(self, '_m_limit_horizontal', None) @property def part_root_name(self): if hasattr(self, '_m_part_root_name'): return self._m_part_root_name self._m_part_root_name = self.base.part_root_name return getattr(self, '_m_part_root_name', None) @property def angular_speed(self): if hasattr(self, '_m_angular_speed'): return self._m_angular_speed self._m_angular_speed = self.base.angular_speed return getattr(self, '_m_angular_speed', None) @property def target_type(self): if hasattr(self, '_m_target_type'): return self._m_target_type self._m_target_type = self.base.target_type return getattr(self, '_m_target_type', None) class ConfigWidgetUseAttachAbilityGroupToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_group_name_second: self.ability_group_name_second = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_update_cd_after_ability_trigger: self.is_update_cd_after_ability_trigger = self._io.read_u1() @property def has_field_ability_group_name_second(self): if hasattr(self, '_m_has_field_ability_group_name_second'): return self._m_has_field_ability_group_name_second self._m_has_field_ability_group_name_second = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_group_name_second', None) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_is_update_cd_after_ability_trigger(self): if hasattr(self, '_m_has_field_is_update_cd_after_ability_trigger'): return self._m_has_field_is_update_cd_after_ability_trigger self._m_has_field_is_update_cd_after_ability_trigger = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_update_cd_after_ability_trigger', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class KvpOfDictAuxTypesVlqBase128LeSArrayOfEnumAiTargetSystemTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ArrayOfEnumAiTargetSystemTypeLengthU(self._io, self, self._root) class EnumAbilityGroupSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityGroupSourceType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringArrayOfInputActionEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfInputActionEventLengthU(self._io, self, self._root)) class EntityDefenceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_defend_trigger_id: self.defend_trigger_id = AuxTypes.String(self._io, self, self._root) if self.has_field_defend_angle: self.defend_angle = self._io.read_f4le() if self.has_field_defend_probability: self.defend_probability = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_defend_probability_delta: self.defend_probability_delta = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_defend_time_interval: self.defend_time_interval = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_always_recover: self.always_recover = self._io.read_u1() if self.has_field_defend_count_interval: self.defend_count_interval = AuxTypes.DynamicInt(self._io, self, self._root) if self.has_field_can_defence_while_endure_full: self.can_defence_while_endure_full = self._io.read_u1() @property def has_field_defend_trigger_id(self): if hasattr(self, '_m_has_field_defend_trigger_id'): return self._m_has_field_defend_trigger_id self._m_has_field_defend_trigger_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_defend_trigger_id', None) @property def has_field_can_defence_while_endure_full(self): if hasattr(self, '_m_has_field_can_defence_while_endure_full'): return self._m_has_field_can_defence_while_endure_full self._m_has_field_can_defence_while_endure_full = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_can_defence_while_endure_full', None) @property def has_field_defend_probability(self): if hasattr(self, '_m_has_field_defend_probability'): return self._m_has_field_defend_probability self._m_has_field_defend_probability = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_defend_probability', None) @property def has_field_defend_probability_delta(self): if hasattr(self, '_m_has_field_defend_probability_delta'): return self._m_has_field_defend_probability_delta self._m_has_field_defend_probability_delta = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_defend_probability_delta', None) @property def has_field_always_recover(self): if hasattr(self, '_m_has_field_always_recover'): return self._m_has_field_always_recover self._m_has_field_always_recover = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_always_recover', None) @property def has_field_defend_time_interval(self): if hasattr(self, '_m_has_field_defend_time_interval'): return self._m_has_field_defend_time_interval self._m_has_field_defend_time_interval = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_defend_time_interval', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_defend_count_interval(self): if hasattr(self, '_m_has_field_defend_count_interval'): return self._m_has_field_defend_count_interval self._m_has_field_defend_count_interval = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_defend_count_interval', None) @property def has_field_defend_angle(self): if hasattr(self, '_m_has_field_defend_angle'): return self._m_has_field_defend_angle self._m_has_field_defend_angle = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_defend_angle', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class PerfCostRatioGradeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BusChannelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bus: self.bus = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_channel_mask: self.channel_mask = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bus(self): if hasattr(self, '_m_has_field_bus'): return self._m_has_field_bus self._m_has_field_bus = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bus', None) @property def has_field_channel_mask(self): if hasattr(self, '_m_has_field_channel_mask'): return self._m_has_field_channel_mask self._m_has_field_channel_mask = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_channel_mask', None) class SealProgressTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GroupKillPolicyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetVelocityIgnoreAirGy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ignore_air_gy: self.ignore_air_gy = self._io.read_u1() @property def has_field_ignore_air_gy(self): if hasattr(self, '_m_has_field_ignore_air_gy'): return self._m_has_field_ignore_air_gy self._m_has_field_ignore_air_gy = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ignore_air_gy', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringEnumTokenForceEnqueueReason(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.EnumTokenForceEnqueueReason(self._io, self, self._root) class DieFlagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AddElementDurability(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_sort_modifier: self.sort_modifier = Output.EnumSortModifierType(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_sort_modifier(self): if hasattr(self, '_m_has_field_sort_modifier'): return self._m_has_field_sort_modifier self._m_has_field_sort_modifier = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_sort_modifier', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_min_value', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_element_type', None) class CoopPointExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPositionModifyState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PositionModifyState, self.data.value) return getattr(self, '_m_value', None) class H5activityWatcherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_h5activity_id: self.h5activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_list: self.cond_list = Output.ArrayOfH5activityCondConfigLengthS(self._io, self, self._root) if self.has_field_is_daily_refresh: self.is_daily_refresh = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_is_daily_refresh(self): if hasattr(self, '_m_has_field_is_daily_refresh'): return self._m_has_field_is_daily_refresh self._m_has_field_is_daily_refresh = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_daily_refresh', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_cond_list(self): if hasattr(self, '_m_has_field_cond_list'): return self._m_has_field_cond_list self._m_has_field_cond_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_trigger_config', None) @property def has_field_h5activity_id(self): if hasattr(self, '_m_has_field_h5activity_id'): return self._m_has_field_h5activity_id self._m_has_field_h5activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_h5activity_id', None) class MaterialCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActivityShopSheetCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityShopSheetCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigBaseStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_priority', None) class FaceAnimationTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) class ConfigSimpleAttackPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_use_custom_shape: self.use_custom_shape = self._io.read_u1() @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def has_field_use_custom_shape(self): if hasattr(self, '_m_has_field_use_custom_shape'): return self._m_has_field_use_custom_shape self._m_has_field_use_custom_shape = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_custom_shape', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class TextMapConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigExternalVoiceInferiorItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_guid: self.guid = AuxTypes.String(self._io, self, self._root) if self.has_field_include: self.include = self._io.read_u1() @property def has_field_guid(self): if hasattr(self, '_m_has_field_guid'): return self._m_has_field_guid self._m_has_field_guid = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_guid', None) @property def has_field_include(self): if hasattr(self, '_m_has_field_include'): return self._m_has_field_include self._m_has_field_include = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_include', None) class GuideKeyClickComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityDeliveryDailyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumScanAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ScanAreaType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfQuestElemSampleLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestElemSample(self._io, self, self._root)) class DictOfAuxTypesStringCustomGadgetNodeSlot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringCustomGadgetNodeSlot(self._io, self, self._root)) class ArrayOfSectrStreamObjectLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrStreamObject(self._io, self, self._root)) class RoutineDetailExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLocalGadgetMoveOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_target_pos: self.target_pos = Output.Vector(self._io, self, self._root) if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_blend_type: self.blend_type = Output.EnumTweenEaseType(self._io, self, self._root) @property def has_field_target_pos(self): if hasattr(self, '_m_has_field_target_pos'): return self._m_has_field_target_pos self._m_has_field_target_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_pos', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_blend_type(self): if hasattr(self, '_m_has_field_blend_type'): return self._m_has_field_blend_type self._m_has_field_blend_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_blend_type', None) class DictOfAuxTypesStringConfigLoadingDoor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigLoadingDoor(self._io, self, self._root)) class EnumRogueMonsterPoolDifficultyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueMonsterPoolDifficultyType, self.data.value) return getattr(self, '_m_value', None) class ByLocalAvatarStamina(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_stamina: self.stamina = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_stamina(self): if hasattr(self, '_m_has_field_stamina'): return self._m_has_field_stamina self._m_has_field_stamina = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stamina', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class CustomGadgetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RunGm(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gm: self.gm = AuxTypes.String(self._io, self, self._root) if self.has_field_flush: self.flush = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_flush(self): if hasattr(self, '_m_has_field_flush'): return self._m_has_field_flush self._m_has_field_flush = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_flush', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_gm(self): if hasattr(self, '_m_has_field_gm'): return self._m_has_field_gm self._m_has_field_gm = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gm', None) class ExecuteGroupTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_source_name: self.source_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_param3', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_source_name(self): if hasattr(self, '_m_has_field_source_name'): return self._m_has_field_source_name self._m_has_field_source_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_source_name', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param2', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param1', None) class BartenderFormulaTypeConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MatchSubTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEntityTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityTriggerType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesVlqBase128LeSConfigAiBrownianMotionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiBrownianMotionData(self._io, self, self._root)) class MonsterSpecialNameExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReplaceFaceAnimationMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_old_face_animations: self.old_face_animations = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_new_face_animations: self.new_face_animations = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_old_face_animations(self): if hasattr(self, '_m_has_field_old_face_animations'): return self._m_has_field_old_face_animations self._m_has_field_old_face_animations = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_old_face_animations', None) @property def has_field_new_face_animations(self): if hasattr(self, '_m_has_field_new_face_animations'): return self._m_has_field_new_face_animations self._m_has_field_new_face_animations = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_new_face_animations', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigEntityAbilityEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ability_id: self.ability_id = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_override: self.ability_override = AuxTypes.String(self._io, self, self._root) if self.has_field_light_weight_remove: self.light_weight_remove = self._io.read_u1() @property def has_field_ability_id(self): if hasattr(self, '_m_has_field_ability_id'): return self._m_has_field_ability_id self._m_has_field_ability_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_id', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_ability_override(self): if hasattr(self, '_m_has_field_ability_override'): return self._m_has_field_ability_override self._m_has_field_ability_override = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_override', None) @property def has_field_light_weight_remove(self): if hasattr(self, '_m_has_field_light_weight_remove'): return self._m_has_field_light_weight_remove self._m_has_field_light_weight_remove = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_light_weight_remove', None) class BattlePassScheduleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_name: self.title_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_date_str: self.begin_date_str = AuxTypes.String(self._io, self, self._root) if self.has_field_end_date_str: self.end_date_str = AuxTypes.String(self._io, self, self._root) if self.has_field_cycle_list: self.cycle_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_extra_paid_reward_id: self.extra_paid_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_paid_add_point: self.extra_paid_add_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buy_level_cost_coin_num: self.buy_level_cost_coin_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cycle_point_upper_limit: self.cycle_point_upper_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_reward_index_id: self.level_reward_index_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_normal_reward_list: self.normal_reward_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_type: self.reward_type = Output.EnumBattlePassScheduleRewardType(self._io, self, self._root) if self.has_field_show_image: self.show_image = AuxTypes.String(self._io, self, self._root) if self.has_field_show_reward_list: self.show_reward_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stroy_reward_list: self.stroy_reward_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_story_id: self.story_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mail_day_count: self.mail_day_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mail_config_id: self.mail_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_buy_level_cost_coin_num(self): if hasattr(self, '_m_has_field_buy_level_cost_coin_num'): return self._m_has_field_buy_level_cost_coin_num self._m_has_field_buy_level_cost_coin_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_buy_level_cost_coin_num', None) @property def has_field_mail_day_count(self): if hasattr(self, '_m_has_field_mail_day_count'): return self._m_has_field_mail_day_count self._m_has_field_mail_day_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_mail_day_count', None) @property def has_field_normal_reward_list(self): if hasattr(self, '_m_has_field_normal_reward_list'): return self._m_has_field_normal_reward_list self._m_has_field_normal_reward_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_normal_reward_list', None) @property def has_field_stroy_reward_list(self): if hasattr(self, '_m_has_field_stroy_reward_list'): return self._m_has_field_stroy_reward_list self._m_has_field_stroy_reward_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_stroy_reward_list', None) @property def has_field_story_id(self): if hasattr(self, '_m_has_field_story_id'): return self._m_has_field_story_id self._m_has_field_story_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_story_id', None) @property def has_field_begin_date_str(self): if hasattr(self, '_m_has_field_begin_date_str'): return self._m_has_field_begin_date_str self._m_has_field_begin_date_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_begin_date_str', None) @property def has_field_end_date_str(self): if hasattr(self, '_m_has_field_end_date_str'): return self._m_has_field_end_date_str self._m_has_field_end_date_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_end_date_str', None) @property def has_field_show_reward_list(self): if hasattr(self, '_m_has_field_show_reward_list'): return self._m_has_field_show_reward_list self._m_has_field_show_reward_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_show_reward_list', None) @property def has_field_cycle_list(self): if hasattr(self, '_m_has_field_cycle_list'): return self._m_has_field_cycle_list self._m_has_field_cycle_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cycle_list', None) @property def has_field_cycle_point_upper_limit(self): if hasattr(self, '_m_has_field_cycle_point_upper_limit'): return self._m_has_field_cycle_point_upper_limit self._m_has_field_cycle_point_upper_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cycle_point_upper_limit', None) @property def has_field_show_image(self): if hasattr(self, '_m_has_field_show_image'): return self._m_has_field_show_image self._m_has_field_show_image = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_show_image', None) @property def has_field_level_reward_index_id(self): if hasattr(self, '_m_has_field_level_reward_index_id'): return self._m_has_field_level_reward_index_id self._m_has_field_level_reward_index_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_level_reward_index_id', None) @property def has_field_extra_paid_add_point(self): if hasattr(self, '_m_has_field_extra_paid_add_point'): return self._m_has_field_extra_paid_add_point self._m_has_field_extra_paid_add_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_extra_paid_add_point', None) @property def has_field_title_name(self): if hasattr(self, '_m_has_field_title_name'): return self._m_has_field_title_name self._m_has_field_title_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_mail_config_id(self): if hasattr(self, '_m_has_field_mail_config_id'): return self._m_has_field_mail_config_id self._m_has_field_mail_config_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_mail_config_id', None) @property def has_field_extra_paid_reward_id(self): if hasattr(self, '_m_has_field_extra_paid_reward_id'): return self._m_has_field_extra_paid_reward_id self._m_has_field_extra_paid_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_extra_paid_reward_id', None) @property def has_field_reward_type(self): if hasattr(self, '_m_has_field_reward_type'): return self._m_has_field_reward_type self._m_has_field_reward_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_reward_type', None) class EnumGuideGeneralConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideGeneralConditionType, self.data.value) return getattr(self, '_m_value', None) class CombatEndTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetBlessingCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_fixed: self.is_fixed = self._io.read_u1() @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_is_fixed(self): if hasattr(self, '_m_has_field_is_fixed'): return self._m_has_field_is_fixed self._m_has_field_is_fixed = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_fixed', None) class SetUiCombatBarAsh(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class MatchPunishExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityCondExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfNewActivityCondLengthS(self._io, self, self._root) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond', None) class ConfigDialogVoiceSegment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QualityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPotionOverallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_param_a: self.score_param_a = self._io.read_f4le() if self.has_field_score_param_b: self.score_param_b = self._io.read_f4le() if self.has_field_score_param_c: self.score_param_c = self._io.read_f4le() @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_score_param_a(self): if hasattr(self, '_m_has_field_score_param_a'): return self._m_has_field_score_param_a self._m_has_field_score_param_a = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_score_param_a', None) @property def has_field_score_param_b(self): if hasattr(self, '_m_has_field_score_param_b'): return self._m_has_field_score_param_b self._m_has_field_score_param_b = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_score_param_b', None) @property def has_field_score_param_c(self): if hasattr(self, '_m_has_field_score_param_c'): return self._m_has_field_score_param_c self._m_has_field_score_param_c = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score_param_c', None) class ConfigEffectAttachBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEffectAttachShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_emit_from: self.emit_from = Output.EnumParticleShapeType(self._io, self, self._root) if self.has_field_scale_x: self.scale_x = self._io.read_f4le() if self.has_field_scale_y: self.scale_y = self._io.read_f4le() if self.has_field_scale_z: self.scale_z = self._io.read_f4le() @property def has_field_emit_from(self): if hasattr(self, '_m_has_field_emit_from'): return self._m_has_field_emit_from self._m_has_field_emit_from = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_emit_from', None) @property def has_field_scale_x(self): if hasattr(self, '_m_has_field_scale_x'): return self._m_has_field_scale_x self._m_has_field_scale_x = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scale_x', None) @property def has_field_scale_y(self): if hasattr(self, '_m_has_field_scale_y'): return self._m_has_field_scale_y self._m_has_field_scale_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale_y', None) @property def has_field_scale_z(self): if hasattr(self, '_m_has_field_scale_z'): return self._m_has_field_scale_z self._m_has_field_scale_z = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_scale_z', None) class EnumCollectorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CollectorType, self.data.value) return getattr(self, '_m_value', None) class ByIsCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumConfigWeatherEffectControlType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigWeatherEffectControlType, self.data.value) return getattr(self, '_m_value', None) class TemplateParamString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TemplateParam(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_origin_value: self.origin_value = AuxTypes.String(self._io, self, self._root) @property def has_field_origin_value(self): if hasattr(self, '_m_has_field_origin_value'): return self._m_has_field_origin_value self._m_has_field_origin_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_origin_value', None) @property def param(self): if hasattr(self, '_m_param'): return self._m_param self._m_param = self.base.param return getattr(self, '_m_param', None) class AttachToAbilityStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_states: self.ability_states = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) if self.has_field_reject: self.reject = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_states(self): if hasattr(self, '_m_has_field_ability_states'): return self._m_has_field_ability_states self._m_has_field_ability_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_states', None) @property def has_field_reject(self): if hasattr(self, '_m_has_field_reject'): return self._m_has_field_reject self._m_has_field_reject = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reject', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAudioCityBlocks(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_music_sub_states: self.music_sub_states = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) @property def has_field_music_sub_states(self): if hasattr(self, '_m_has_field_music_sub_states'): return self._m_has_field_music_sub_states self._m_has_field_music_sub_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_music_sub_states', None) class ContextActionReportActivityBuriedPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_button_id: self.button_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_additional_info: self.additional_info = AuxTypes.String(self._io, self, self._root) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_activity_id', None) @property def has_field_button_id(self): if hasattr(self, '_m_has_field_button_id'): return self._m_has_field_button_id self._m_has_field_button_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_button_id', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_additional_info(self): if hasattr(self, '_m_has_field_additional_info'): return self._m_has_field_additional_info self._m_has_field_additional_info = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_additional_info', None) class PlayerUidNotifyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_op_param: self.op_param = AuxTypes.String(self._io, self, self._root) if self.has_field_op_type: self.op_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_op_type(self): if hasattr(self, '_m_has_field_op_type'): return self._m_has_field_op_type self._m_has_field_op_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_op_type', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def has_field_op_param(self): if hasattr(self, '_m_has_field_op_param'): return self._m_has_field_op_param self._m_has_field_op_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_op_param', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicDoubleCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f8le() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ActCameraShake(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_shake: self.camera_shake = Output.ConfigCameraShake(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_camera_shake(self): if hasattr(self, '_m_has_field_camera_shake'): return self._m_has_field_camera_shake self._m_has_field_camera_shake = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_shake', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class ConfigDirectionByAttachPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attach_point_name: self.attach_point_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_point_target_type: self.attach_point_target_type = Output.EnumAttachPointTargetType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def has_field_attach_point_target_type(self): if hasattr(self, '_m_has_field_attach_point_target_type'): return self._m_has_field_attach_point_target_type self._m_has_field_attach_point_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_point_target_type', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def has_field_attach_point_name(self): if hasattr(self, '_m_has_field_attach_point_name'): return self._m_has_field_attach_point_name self._m_has_field_attach_point_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_point_name', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class ConfigPlatformUiData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_base_canvans_action: self.base_canvans_action = Output.ConfigPlatformUiAction(self._io, self, self._root) if self.has_field_base_page_action: self.base_page_action = Output.ConfigPlatformUiAction(self._io, self, self._root) if self.has_field_context_actions: self.context_actions = Output.DictOfAuxTypesStringConfigPlatformUiAction(self._io, self, self._root) @property def has_field_base_canvans_action(self): if hasattr(self, '_m_has_field_base_canvans_action'): return self._m_has_field_base_canvans_action self._m_has_field_base_canvans_action = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_base_canvans_action', None) @property def has_field_base_page_action(self): if hasattr(self, '_m_has_field_base_page_action'): return self._m_has_field_base_page_action self._m_has_field_base_page_action = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_base_page_action', None) @property def has_field_context_actions(self): if hasattr(self, '_m_has_field_context_actions'): return self._m_has_field_context_actions self._m_has_field_context_actions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_context_actions', None) class RefreshRainOccluder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigPlatformUiAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_paths: self.paths = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_indent: self.indent = self._io.read_f4le() if self.has_field_scale: self.scale = self._io.read_f4le() if self.has_field_top: self.top = self._io.read_f4le() if self.has_field_bottom: self.bottom = self._io.read_f4le() if self.has_field_left: self.left = self._io.read_f4le() if self.has_field_right: self.right = self._io.read_f4le() if self.has_field_posx: self.posx = self._io.read_f4le() if self.has_field_posy: self.posy = self._io.read_f4le() if self.has_field_active: self.active = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_first_active: self.first_active = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_animation: self.animation = AuxTypes.String(self._io, self, self._root) @property def has_field_paths(self): if hasattr(self, '_m_has_field_paths'): return self._m_has_field_paths self._m_has_field_paths = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_paths', None) @property def has_field_active(self): if hasattr(self, '_m_has_field_active'): return self._m_has_field_active self._m_has_field_active = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_active', None) @property def has_field_bottom(self): if hasattr(self, '_m_has_field_bottom'): return self._m_has_field_bottom self._m_has_field_bottom = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_bottom', None) @property def has_field_indent(self): if hasattr(self, '_m_has_field_indent'): return self._m_has_field_indent self._m_has_field_indent = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_indent', None) @property def has_field_posy(self): if hasattr(self, '_m_has_field_posy'): return self._m_has_field_posy self._m_has_field_posy = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_posy', None) @property def has_field_posx(self): if hasattr(self, '_m_has_field_posx'): return self._m_has_field_posx self._m_has_field_posx = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_posx', None) @property def has_field_first_active(self): if hasattr(self, '_m_has_field_first_active'): return self._m_has_field_first_active self._m_has_field_first_active = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_first_active', None) @property def has_field_right(self): if hasattr(self, '_m_has_field_right'): return self._m_has_field_right self._m_has_field_right = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_right', None) @property def has_field_top(self): if hasattr(self, '_m_has_field_top'): return self._m_has_field_top self._m_has_field_top = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_top', None) @property def has_field_animation(self): if hasattr(self, '_m_has_field_animation'): return self._m_has_field_animation self._m_has_field_animation = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_animation', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_left(self): if hasattr(self, '_m_has_field_left'): return self._m_has_field_left self._m_has_field_left = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_left', None) class EnumEffigyDifficulty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EffigyDifficulty, self.data.value) return getattr(self, '_m_value', None) class SetChargeBarValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigBaseInputAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value_type: self.value_type = Output.EnumInputValueType(self._io, self, self._root) if self.has_field_description_text_id: self.description_text_id = AuxTypes.String(self._io, self, self._root) @property def has_field_value_type(self): if hasattr(self, '_m_has_field_value_type'): return self._m_has_field_value_type self._m_has_field_value_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_type', None) @property def has_field_description_text_id(self): if hasattr(self, '_m_has_field_description_text_id'): return self._m_has_field_description_text_id self._m_has_field_description_text_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_description_text_id', None) class ReactionEnergyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReliquaryAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TdPlayMixinV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tower_type: self.tower_type = Output.EnumTdPlayTowerType(self._io, self, self._root) if self.has_field_base_cd: self.base_cd = self._io.read_f4le() if self.has_field_base_attack_range: self.base_attack_range = self._io.read_f4le() if self.has_field_on_fire_actions: self.on_fire_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_bullet_id: self.bullet_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_part_root_names: self.part_root_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumControlPartTargetType(self._io, self, self._root) @property def has_field_on_fire_actions(self): if hasattr(self, '_m_has_field_on_fire_actions'): return self._m_has_field_on_fire_actions self._m_has_field_on_fire_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_fire_actions', None) @property def has_field_bullet_id(self): if hasattr(self, '_m_has_field_bullet_id'): return self._m_has_field_bullet_id self._m_has_field_bullet_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_bullet_id', None) @property def has_field_base_attack_range(self): if hasattr(self, '_m_has_field_base_attack_range'): return self._m_has_field_base_attack_range self._m_has_field_base_attack_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_base_attack_range', None) @property def has_field_base_cd(self): if hasattr(self, '_m_has_field_base_cd'): return self._m_has_field_base_cd self._m_has_field_base_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_base_cd', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_born', None) @property def has_field_part_root_names(self): if hasattr(self, '_m_has_field_part_root_names'): return self._m_has_field_part_root_names self._m_has_field_part_root_names = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_part_root_names', None) @property def has_field_tower_type(self): if hasattr(self, '_m_has_field_tower_type'): return self._m_has_field_tower_type self._m_has_field_tower_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tower_type', None) class BaseTalentConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_open_config: self.open_config = AuxTypes.String(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthU(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_open_config(self): if hasattr(self, '_m_has_field_open_config'): return self._m_has_field_open_config self._m_has_field_open_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_open_config', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_add_props', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param_list', None) class EnumInputEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InputEventType, self.data.value) return getattr(self, '_m_value', None) class RocketJumpMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.BaseSwitchMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumRocketJumpType(self._io, self, self._root) if self.has_field_extention: self.extention = Output.RocketJumpExt(self._io, self, self._root) if self.has_field_ui_effect: self.ui_effect = self._io.read_u1() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_extention(self): if hasattr(self, '_m_has_field_extention'): return self._m_has_field_extention self._m_has_field_extention = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_extention', None) @property def has_field_ui_effect(self): if hasattr(self, '_m_has_field_ui_effect'): return self._m_has_field_ui_effect self._m_has_field_ui_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ui_effect', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigActionTokenChannel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_num', None) class ConfigAuxObjectRegistry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShapeSphere(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) class ConfigBornType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_offset: self.offset = Output.DynamicFloatVector(self._io, self, self._root) if self.has_field_born_random: self.born_random = Output.DispBornRandom(self._io, self, self._root) if self.has_field_on_ground: self.on_ground = self._io.read_u1() if self.has_field_on_ground_ignore_water: self.on_ground_ignore_water = self._io.read_u1() if self.has_field_on_ground_raycast_up_dist: self.on_ground_raycast_up_dist = self._io.read_f4le() if self.has_field_direction: self.direction = Output.DispConfigBornDirectionType(self._io, self, self._root) if self.has_field_along_ground: self.along_ground = self._io.read_u1() if self.has_field_use_rotation: self.use_rotation = self._io.read_u1() @property def has_field_direction(self): if hasattr(self, '_m_has_field_direction'): return self._m_has_field_direction self._m_has_field_direction = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_direction', None) @property def has_field_born_random(self): if hasattr(self, '_m_has_field_born_random'): return self._m_has_field_born_random self._m_has_field_born_random = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born_random', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_use_rotation(self): if hasattr(self, '_m_has_field_use_rotation'): return self._m_has_field_use_rotation self._m_has_field_use_rotation = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_use_rotation', None) @property def has_field_on_ground(self): if hasattr(self, '_m_has_field_on_ground'): return self._m_has_field_on_ground self._m_has_field_on_ground = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_ground', None) @property def has_field_on_ground_ignore_water(self): if hasattr(self, '_m_has_field_on_ground_ignore_water'): return self._m_has_field_on_ground_ignore_water self._m_has_field_on_ground_ignore_water = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_ground_ignore_water', None) @property def has_field_along_ground(self): if hasattr(self, '_m_has_field_along_ground'): return self._m_has_field_along_ground self._m_has_field_along_ground = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_along_ground', None) @property def has_field_on_ground_raycast_up_dist(self): if hasattr(self, '_m_has_field_on_ground_raycast_up_dist'): return self._m_has_field_on_ground_raycast_up_dist self._m_has_field_on_ground_raycast_up_dist = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_ground_raycast_up_dist', None) class CityLevelupConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGearLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ContextConditionOr(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_conditions: self.conditions = Output.ArrayOfDispContextConditionLengthU(self._io, self, self._root) @property def has_field_conditions(self): if hasattr(self, '_m_has_field_conditions'): return self._m_has_field_conditions self._m_has_field_conditions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_conditions', None) class ActivitySpiceStageDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day_index: self.open_day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_inc_cnt_limit: self.fetter_inc_cnt_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id_list: self.material_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_material_num_list: self.material_num_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_material_order_list: self.material_order_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed: self.speed = self._io.read_f4le() if self.has_field_times: self.times = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_click_num: self.click_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_click_zone: self.click_zone = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_speed(self): if hasattr(self, '_m_has_field_speed'): return self._m_has_field_speed self._m_has_field_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_speed', None) @property def has_field_material_id_list(self): if hasattr(self, '_m_has_field_material_id_list'): return self._m_has_field_material_id_list self._m_has_field_material_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_material_id_list', None) @property def has_field_material_num_list(self): if hasattr(self, '_m_has_field_material_num_list'): return self._m_has_field_material_num_list self._m_has_field_material_num_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_material_num_list', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_open_day_index(self): if hasattr(self, '_m_has_field_open_day_index'): return self._m_has_field_open_day_index self._m_has_field_open_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day_index', None) @property def has_field_material_order_list(self): if hasattr(self, '_m_has_field_material_order_list'): return self._m_has_field_material_order_list self._m_has_field_material_order_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_material_order_list', None) @property def has_field_times(self): if hasattr(self, '_m_has_field_times'): return self._m_has_field_times self._m_has_field_times = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_times', None) @property def has_field_click_num(self): if hasattr(self, '_m_has_field_click_num'): return self._m_has_field_click_num self._m_has_field_click_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_click_num', None) @property def has_field_click_zone(self): if hasattr(self, '_m_has_field_click_zone'): return self._m_has_field_click_zone self._m_has_field_click_zone = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_click_zone', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_fetter_inc_cnt_limit(self): if hasattr(self, '_m_has_field_fetter_inc_cnt_limit'): return self._m_has_field_fetter_inc_cnt_limit self._m_has_field_fetter_inc_cnt_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_fetter_inc_cnt_limit', None) class ArrayOfDispConfigJudgeNodeBaseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigJudgeNodeBase(self._io, self, self._root)) class EnumGalleryProgressScoreUiType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GalleryProgressScoreUiType, self.data.value) return getattr(self, '_m_value', None) class ComponentTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RemoveVelocityForce(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_forces: self.forces = Output.ArrayOfEnumVelocityForceTypeLengthU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_forces(self): if hasattr(self, '_m_has_field_forces'): return self._m_has_field_forces self._m_has_field_forces = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_forces', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesVlqBase128LeSConfigAiFishingFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingFleeData(self._io, self, self._root)) class ActivitySalesmanRewardMatchConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEntityBanData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_ban_map: self.entity_ban_map = Output.DictOfAuxTypesStringArrayOfConfigEntityBlackGrpLengthU(self._io, self, self._root) @property def has_field_entity_ban_map(self): if hasattr(self, '_m_has_field_entity_ban_map'): return self._m_has_field_entity_ban_map self._m_has_field_entity_ban_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_ban_map', None) class ByHitCritical(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigMusicCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_res_name: self.res_name = AuxTypes.String(self._io, self, self._root) if self.has_field_condition_list: self.condition_list = Output.ArrayOfCameraPlayConditionLengthU(self._io, self, self._root) if self.has_field_style: self.style = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_disable_dither: self.disable_dither = self._io.read_u1() @property def has_field_res_name(self): if hasattr(self, '_m_has_field_res_name'): return self._m_has_field_res_name self._m_has_field_res_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_res_name', None) @property def has_field_condition_list(self): if hasattr(self, '_m_has_field_condition_list'): return self._m_has_field_condition_list self._m_has_field_condition_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_condition_list', None) @property def has_field_style(self): if hasattr(self, '_m_has_field_style'): return self._m_has_field_style self._m_has_field_style = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_style', None) @property def has_field_disable_dither(self): if hasattr(self, '_m_has_field_disable_dither'): return self._m_has_field_disable_dither self._m_has_field_disable_dither = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_disable_dither', None) class ActionSlotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryRoomTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_normal_room_config_list: self.normal_room_config_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hard_room_config_list: self.hard_room_config_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_normal_room_config_list(self): if hasattr(self, '_m_has_field_normal_room_config_list'): return self._m_has_field_normal_room_config_list self._m_has_field_normal_room_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_normal_room_config_list', None) @property def has_field_hard_room_config_list(self): if hasattr(self, '_m_has_field_hard_room_config_list'): return self._m_has_field_hard_room_config_list self._m_has_field_hard_room_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hard_room_config_list', None) class AttackReviveEnergyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_max_value: self.max_value = self._io.read_f4le() if self.has_field_min_value: self.min_value = self._io.read_f4le() if self.has_field_add_value: self.add_value = self._io.read_f4le() if self.has_field_revive_action: self.revive_action = Output.DispConfigAbilityAction(self._io, self, self._root) if self.has_field_fire_effect_actions: self.fire_effect_actions = Output.DictOfEnumElementTypeDispConfigAbilityAction(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_add_value(self): if hasattr(self, '_m_has_field_add_value'): return self._m_has_field_add_value self._m_has_field_add_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_add_value', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_fire_effect_actions(self): if hasattr(self, '_m_has_field_fire_effect_actions'): return self._m_has_field_fire_effect_actions self._m_has_field_fire_effect_actions = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_fire_effect_actions', None) @property def has_field_revive_action(self): if hasattr(self, '_m_has_field_revive_action'): return self._m_has_field_revive_action self._m_has_field_revive_action = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_revive_action', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tags', None) class ConfigMusicStringAbsenceStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicStringMultiValueStimulusHandler(self._io, self, self._root) @property def string_params(self): if hasattr(self, '_m_string_params'): return self._m_string_params self._m_string_params = self.base.string_params return getattr(self, '_m_string_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class ChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_quest_id: self.begin_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_quest_id: self.end_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_player_level: self.need_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_begin_time_str: self.need_begin_time_str = AuxTypes.String(self._io, self, self._root) if self.has_field_chapter_num: self.chapter_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_title: self.chapter_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_icon: self.chapter_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_chapter_image_hash: self.chapter_image_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_image_hash: self.chapter_image_hash_pre = self._io.read_s1() if self.has_field_chapter_image_title: self.chapter_image_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_in_activity_need_player_level: self.in_activity_need_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_serial_number_icon: self.chapter_serial_number_icon = AuxTypes.String(self._io, self, self._root) @property def has_field_in_activity_need_player_level(self): if hasattr(self, '_m_has_field_in_activity_need_player_level'): return self._m_has_field_in_activity_need_player_level self._m_has_field_in_activity_need_player_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_in_activity_need_player_level', None) @property def has_field_need_begin_time_str(self): if hasattr(self, '_m_has_field_need_begin_time_str'): return self._m_has_field_need_begin_time_str self._m_has_field_need_begin_time_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_need_begin_time_str', None) @property def has_field_chapter_num(self): if hasattr(self, '_m_has_field_chapter_num'): return self._m_has_field_chapter_num self._m_has_field_chapter_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_chapter_num', None) @property def has_field_chapter_image_hash(self): if hasattr(self, '_m_has_field_chapter_image_hash'): return self._m_has_field_chapter_image_hash self._m_has_field_chapter_image_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_chapter_image_hash', None) @property def has_field_chapter_image_title(self): if hasattr(self, '_m_has_field_chapter_image_title'): return self._m_has_field_chapter_image_title self._m_has_field_chapter_image_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_chapter_image_title', None) @property def has_field_begin_quest_id(self): if hasattr(self, '_m_has_field_begin_quest_id'): return self._m_has_field_begin_quest_id self._m_has_field_begin_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_begin_quest_id', None) @property def has_field_chapter_title(self): if hasattr(self, '_m_has_field_chapter_title'): return self._m_has_field_chapter_title self._m_has_field_chapter_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_chapter_title', None) @property def has_field_chapter_icon(self): if hasattr(self, '_m_has_field_chapter_icon'): return self._m_has_field_chapter_icon self._m_has_field_chapter_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_chapter_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_end_quest_id(self): if hasattr(self, '_m_has_field_end_quest_id'): return self._m_has_field_end_quest_id self._m_has_field_end_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_end_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_need_player_level(self): if hasattr(self, '_m_has_field_need_player_level'): return self._m_has_field_need_player_level self._m_has_field_need_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_need_player_level', None) @property def has_field_chapter_serial_number_icon(self): if hasattr(self, '_m_has_field_chapter_serial_number_icon'): return self._m_has_field_chapter_serial_number_icon self._m_has_field_chapter_serial_number_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_chapter_serial_number_icon', None) class EnumBattleFervorStateIdTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BattleFervorStateIdTriggerType, self.data.value) return getattr(self, '_m_value', None) class BooksCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTalkShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkShowType, self.data.value) return getattr(self, '_m_value', None) class DispConfigAbilityPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 93: self.data = Output.ByTargetHpValue(self._io, self, self._root) elif _on == 105: self.data = Output.ByEnergy(self._io, self, self._root) elif _on == 14: self.data = Output.ByTargetElement(self._io, self, self._root) elif _on == 61: self.data = Output.ByHasShieldBar(self._io, self, self._root) elif _on == 10: self.data = Output.ByAny(self._io, self, self._root) elif _on == 17: self.data = Output.ByTargetGlobalValue(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigAbilityPredicate(self._io, self, self._root) elif _on == 47: self.data = Output.ByBigTeamHasWeaponType(self._io, self, self._root) elif _on == 73: self.data = Output.ByTargetIsCaster(self._io, self, self._root) elif _on == 4: self.data = Output.ByWetHitCollider(self._io, self, self._root) elif _on == 42: self.data = Output.ByCurTeamHasBodyType(self._io, self, self._root) elif _on == 46: self.data = Output.ByBigTeamElementTypeSort(self._io, self, self._root) elif _on == 81: self.data = Output.ByHasModifier(self._io, self, self._root) elif _on == 39: self.data = Output.ByCurTeamElementTypeSort(self._io, self, self._root) elif _on == 60: self.data = Output.ByHasShield(self._io, self, self._root) elif _on == 24: self.data = Output.ByIsMoveOnWater(self._io, self, self._root) elif _on == 35: self.data = Output.ByAvatarWeaponType(self._io, self, self._root) elif _on == 6: self.data = Output.ByHitBoxType(self._io, self, self._root) elif _on == 62: self.data = Output.ByEquipAffixReady(self._io, self, self._root) elif _on == 20: self.data = Output.ByEntityTypes(self._io, self, self._root) elif _on == 32: self.data = Output.ByItemNumber(self._io, self, self._root) elif _on == 7: self.data = Output.ByHasElement(self._io, self, self._root) elif _on == 96: self.data = Output.ByTargetOverrideMapValue(self._io, self, self._root) elif _on == 1: self.data = Output.RelationalOperationPredicate(self._io, self, self._root) elif _on == 55: self.data = Output.ByElementReactionType(self._io, self, self._root) elif _on == 27: self.data = Output.ByUnlockTalentParam(self._io, self, self._root) elif _on == 97: self.data = Output.ByTargetWeight(self._io, self, self._root) elif _on == 77: self.data = Output.ByCurrentSceneTypes(self._io, self, self._root) elif _on == 106: self.data = Output.BySummonTagValue(self._io, self, self._root) elif _on == 13: self.data = Output.ByTargetIsSelf(self._io, self, self._root) elif _on == 52: self.data = Output.ByEntityAppearVisionType(self._io, self, self._root) elif _on == 56: self.data = Output.ByTargetConfigId(self._io, self, self._root) elif _on == 101: self.data = Output.ByTargetPositionToSelfPosition(self._io, self, self._root) elif _on == 100: self.data = Output.ByAnimatorBool(self._io, self, self._root) elif _on == 45: self.data = Output.ByBigTeamHasElementType(self._io, self, self._root) elif _on == 87: self.data = Output.ByDungeonSettled(self._io, self, self._root) elif _on == 66: self.data = Output.ByTargetLayoutArea(self._io, self, self._root) elif _on == 91: self.data = Output.ByLocalAvatarStamina(self._io, self, self._root) elif _on == 107: self.data = Output.ByAttackNotHitScene(self._io, self, self._root) elif _on == 89: self.data = Output.ByIsInReconnect(self._io, self, self._root) elif _on == 104: self.data = Output.ByEnergyRatio(self._io, self, self._root) elif _on == 98: self.data = Output.ByAnimatorFloat(self._io, self, self._root) elif _on == 85: self.data = Output.ByHaveMoveInput(self._io, self, self._root) elif _on == 11: self.data = Output.ByHasAttackTarget(self._io, self, self._root) elif _on == 67: self.data = Output.ByPlayerClimateType(self._io, self, self._root) elif _on == 69: self.data = Output.ByIsGadgetExistAround(self._io, self, self._root) elif _on == 95: self.data = Output.ByHitEnBreak(self._io, self, self._root) elif _on == 12: self.data = Output.ByTargetIsGhostToEnemy(self._io, self, self._root) elif _on == 59: self.data = Output.ByDieStateFlag(self._io, self, self._root) elif _on == 88: self.data = Output.BySceneLoaded(self._io, self, self._root) elif _on == 58: self.data = Output.ByTargetGadgetState(self._io, self, self._root) elif _on == 3: self.data = Output.ByHitCritical(self._io, self, self._root) elif _on == 5: self.data = Output.ByHitBoxName(self._io, self, self._root) elif _on == 33: self.data = Output.ByHasFeatureTag(self._io, self, self._root) elif _on == 103: self.data = Output.BySelfForwardAndTargetPosition(self._io, self, self._root) elif _on == 99: self.data = Output.ByAnimatorInt(self._io, self, self._root) elif _on == 82: self.data = Output.ByFindBlinkPointSuccess(self._io, self, self._root) elif _on == 86: self.data = Output.ByTargetSkillPoint(self._io, self, self._root) elif _on == 19: self.data = Output.ByAvatarInWaterDepth(self._io, self, self._root) elif _on == 84: self.data = Output.ByWidgetExCdReady(self._io, self, self._root) elif _on == 63: self.data = Output.ByTargetInArea(self._io, self, self._root) elif _on == 51: self.data = Output.ByAttackType(self._io, self, self._root) elif _on == 23: self.data = Output.ByHitStrikeType(self._io, self, self._root) elif _on == 83: self.data = Output.ByFollowTargetValid(self._io, self, self._root) elif _on == 48: self.data = Output.ByBigTeamWeaponTypeSort(self._io, self, self._root) elif _on == 78: self.data = Output.ByTargetType(self._io, self, self._root) elif _on == 53: self.data = Output.ByElementTriggerEntityType(self._io, self, self._root) elif _on == 15: self.data = Output.ByHostOrGuest(self._io, self, self._root) elif _on == 8: self.data = Output.ByHasAbilityState(self._io, self, self._root) elif _on == 38: self.data = Output.ByCurTeamHasElementType(self._io, self, self._root) elif _on == 40: self.data = Output.ByCurTeamHasWeaponType(self._io, self, self._root) elif _on == 64: self.data = Output.ByIsTargetCamp(self._io, self, self._root) elif _on == 65: self.data = Output.ByHasChildGadget(self._io, self, self._root) elif _on == 94: self.data = Output.ByHitDamage(self._io, self, self._root) elif _on == 44: self.data = Output.ByBigTeamHasFeatureTag(self._io, self, self._root) elif _on == 76: self.data = Output.ByHasLevelTag(self._io, self, self._root) elif _on == 109: self.data = Output.ByCompareWithTarget(self._io, self, self._root) elif _on == 79: self.data = Output.ByCurrentSceneId(self._io, self, self._root) elif _on == 57: self.data = Output.ByIsLocalAvatar(self._io, self, self._root) elif _on == 9: self.data = Output.ByNot(self._io, self, self._root) elif _on == 21: self.data = Output.ByHitImpulse(self._io, self, self._root) elif _on == 37: self.data = Output.ByCurTeamHasFeatureTag(self._io, self, self._root) elif _on == 108: self.data = Output.ByTargetAltitude(self._io, self, self._root) elif _on == 41: self.data = Output.ByCurTeamWeaponTypeSort(self._io, self, self._root) elif _on == 72: self.data = Output.ByGameTimeIsLocked(self._io, self, self._root) elif _on == 71: self.data = Output.ByMonsterAirState(self._io, self, self._root) elif _on == 36: self.data = Output.ByAvatarBodyType(self._io, self, self._root) elif _on == 70: self.data = Output.ByEntityIsAlive(self._io, self, self._root) elif _on == 28: self.data = Output.BySkillReady(self._io, self, self._root) elif _on == 74: self.data = Output.ByHitElementDurability(self._io, self, self._root) elif _on == 16: self.data = Output.ByAvatarIsHost(self._io, self, self._root) elif _on == 18: self.data = Output.ByScenePropState(self._io, self, self._root) elif _on == 80: self.data = Output.ByTargetChargeValue(self._io, self, self._root) elif _on == 102: self.data = Output.ByTargetForwardAndSelfPosition(self._io, self, self._root) elif _on == 68: self.data = Output.ByTargetWeatherName(self._io, self, self._root) elif _on == 110: self.data = Output.ByGlobalPosToGround(self._io, self, self._root) elif _on == 26: self.data = Output.BySceneSurfaceType(self._io, self, self._root) elif _on == 31: self.data = Output.ByStageIsReadyTemp(self._io, self, self._root) elif _on == 49: self.data = Output.ByBigTeamHasBodyType(self._io, self, self._root) elif _on == 2: self.data = Output.ByTargetRaycastVisiable(self._io, self, self._root) elif _on == 34: self.data = Output.ByAvatarElementType(self._io, self, self._root) elif _on == 54: self.data = Output.ByElementReactionSourceType(self._io, self, self._root) elif _on == 29: self.data = Output.ByIsCombat(self._io, self, self._root) elif _on == 75: self.data = Output.ByHasTag(self._io, self, self._root) elif _on == 92: self.data = Output.ByLocalAvatarStaminaRatio(self._io, self, self._root) elif _on == 111: self.data = Output.ByHasShieldV2(self._io, self, self._root) elif _on == 25: self.data = Output.ByAttackTags(self._io, self, self._root) elif _on == 43: self.data = Output.ByCurTeamBodyTypeSort(self._io, self, self._root) elif _on == 50: self.data = Output.ByBigTeamBodyTypeSort(self._io, self, self._root) elif _on == 22: self.data = Output.ByHitElement(self._io, self, self._root) elif _on == 30: self.data = Output.ByVehicleIsCombat(self._io, self, self._root) elif _on == 90: self.data = Output.ByTargetHpRatio(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigLuaSafetyCheckSwitch(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tick_world: self.tick_world = self._io.read_u1() if self.has_field_tick_world_cd: self.tick_world_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tick_chest: self.tick_chest = self._io.read_u1() if self.has_field_tick_monster: self.tick_monster = self._io.read_u1() @property def has_field_tick_world(self): if hasattr(self, '_m_has_field_tick_world'): return self._m_has_field_tick_world self._m_has_field_tick_world = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tick_world', None) @property def has_field_tick_world_cd(self): if hasattr(self, '_m_has_field_tick_world_cd'): return self._m_has_field_tick_world_cd self._m_has_field_tick_world_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tick_world_cd', None) @property def has_field_tick_chest(self): if hasattr(self, '_m_has_field_tick_chest'): return self._m_has_field_tick_chest self._m_has_field_tick_chest = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_tick_chest', None) @property def has_field_tick_monster(self): if hasattr(self, '_m_has_field_tick_monster'): return self._m_has_field_tick_monster self._m_has_field_tick_monster = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_tick_monster', None) class KvpOfDictU1ArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = self._io.read_u1() self.value = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) class EffigyChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab: self.prefab = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limiting_condition_vec: self.limiting_condition_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_up_avatar_vec: self.up_avatar_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_first_pass_reward_id: self.first_pass_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_first_pass_reward_id(self): if hasattr(self, '_m_has_field_first_pass_reward_id'): return self._m_has_field_first_pass_reward_id self._m_has_field_first_pass_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_first_pass_reward_id', None) @property def has_field_up_avatar_vec(self): if hasattr(self, '_m_has_field_up_avatar_vec'): return self._m_has_field_up_avatar_vec self._m_has_field_up_avatar_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_up_avatar_vec', None) @property def has_field_limiting_condition_vec(self): if hasattr(self, '_m_has_field_limiting_condition_vec'): return self._m_has_field_limiting_condition_vec self._m_has_field_limiting_condition_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_limiting_condition_vec', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_content', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_prefab(self): if hasattr(self, '_m_has_field_prefab'): return self._m_has_field_prefab self._m_has_field_prefab = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_prefab', None) class KvpOfDictAuxTypesStringConfigAnimationRecurrentSpeech(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAnimationRecurrentSpeech(self._io, self, self._root) class EnumLogicOperation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LogicOperation, self.data.value) return getattr(self, '_m_value', None) class AnimalDescribeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioStageEvents(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_stage_create_events: self.stage_create_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_stage_progress_events: self.stage_progress_events = Output.ArrayOfConfigAudioStageProgressEventLengthU(self._io, self, self._root) if self.has_field_stage_start_events: self.stage_start_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_stage_mature_events: self.stage_mature_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_stage_teleport_events: self.stage_teleport_events = Output.ArrayOfConfigAudioStageProgressEventLengthU(self._io, self, self._root) if self.has_field_stage_exit_events: self.stage_exit_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_state_value: self.state_value = AuxTypes.String(self._io, self, self._root) if self.has_field_stage_create_state_groups: self.stage_create_state_groups = Output.ArrayOfConfigAudioStateGroupLengthU(self._io, self, self._root) if self.has_field_stage_start_state_groups: self.stage_start_state_groups = Output.ArrayOfConfigAudioStateGroupLengthU(self._io, self, self._root) if self.has_field_stage_mature_state_groups: self.stage_mature_state_groups = Output.ArrayOfConfigAudioStateGroupLengthU(self._io, self, self._root) if self.has_field_stage_exit_state_groups: self.stage_exit_state_groups = Output.ArrayOfConfigAudioStateGroupLengthU(self._io, self, self._root) @property def has_field_state_value(self): if hasattr(self, '_m_has_field_state_value'): return self._m_has_field_state_value self._m_has_field_state_value = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_state_value', None) @property def has_field_stage_exit_events(self): if hasattr(self, '_m_has_field_stage_exit_events'): return self._m_has_field_stage_exit_events self._m_has_field_stage_exit_events = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_stage_exit_events', None) @property def has_field_stage_progress_events(self): if hasattr(self, '_m_has_field_stage_progress_events'): return self._m_has_field_stage_progress_events self._m_has_field_stage_progress_events = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_stage_progress_events', None) @property def has_field_stage_mature_events(self): if hasattr(self, '_m_has_field_stage_mature_events'): return self._m_has_field_stage_mature_events self._m_has_field_stage_mature_events = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_stage_mature_events', None) @property def has_field_stage_create_events(self): if hasattr(self, '_m_has_field_stage_create_events'): return self._m_has_field_stage_create_events self._m_has_field_stage_create_events = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_stage_create_events', None) @property def has_field_stage_start_events(self): if hasattr(self, '_m_has_field_stage_start_events'): return self._m_has_field_stage_start_events self._m_has_field_stage_start_events = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_stage_start_events', None) @property def has_field_stage_start_state_groups(self): if hasattr(self, '_m_has_field_stage_start_state_groups'): return self._m_has_field_stage_start_state_groups self._m_has_field_stage_start_state_groups = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_stage_start_state_groups', None) @property def has_field_stage_create_state_groups(self): if hasattr(self, '_m_has_field_stage_create_state_groups'): return self._m_has_field_stage_create_state_groups self._m_has_field_stage_create_state_groups = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_stage_create_state_groups', None) @property def has_field_stage_mature_state_groups(self): if hasattr(self, '_m_has_field_stage_mature_state_groups'): return self._m_has_field_stage_mature_state_groups self._m_has_field_stage_mature_state_groups = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_stage_mature_state_groups', None) @property def has_field_stage_teleport_events(self): if hasattr(self, '_m_has_field_stage_teleport_events'): return self._m_has_field_stage_teleport_events self._m_has_field_stage_teleport_events = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_stage_teleport_events', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_stage_exit_state_groups(self): if hasattr(self, '_m_has_field_stage_exit_state_groups'): return self._m_has_field_stage_exit_state_groups self._m_has_field_stage_exit_state_groups = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_stage_exit_state_groups', None) class ArrayOfConfigGuideWidgetContentLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGuideWidgetContent(self._io, self, self._root)) class MechanicusCardEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMoveCorrection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ModifyAvatarSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_slot: self.skill_slot = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cd_delta: self.cd_delta = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cd_ratio: self.cd_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_skill_slot(self): if hasattr(self, '_m_has_field_skill_slot'): return self._m_has_field_skill_slot self._m_has_field_skill_slot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_slot', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cd_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_cd_delta(self): if hasattr(self, '_m_has_field_cd_delta'): return self._m_has_field_cd_delta self._m_has_field_cd_delta = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_delta', None) class QteStepExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_path: self.config_path = AuxTypes.String(self._io, self, self._root) if self.has_field_next_step: self.next_step = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_config_path(self): if hasattr(self, '_m_has_field_config_path'): return self._m_has_field_config_path self._m_has_field_config_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_config_path', None) @property def has_field_next_step(self): if hasattr(self, '_m_has_field_next_step'): return self._m_has_field_next_step self._m_has_field_next_step = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_next_step', None) class ArrayOfBartenderMaterialLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BartenderMaterial(self._io, self, self._root)) class IrodoriChessGearExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigRecordFrameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRecordFrame(self._io, self, self._root)) class OfferingLevelUpExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopGoodsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_goods_id: self.goods_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_tag_name: self.sub_tag_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_tab_id: self.sub_tab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate_id: self.rotate_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_id: self.show_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_count: self.item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_scoin: self.cost_scoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_hcoin: self.cost_hcoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_mcoin: self.cost_mcoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_rate: self.discount_rate = self._io.read_f4le() if self.has_field_original_price: self.original_price = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_buy_limit: self.buy_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_type: self.refresh_type = Output.EnumShopRefreshType(self._io, self, self._root) if self.has_field_refresh_param: self.refresh_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_days_before_sell: self.display_days_before_sell = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_time: self.begin_time = AuxTypes.String(self._io, self, self._root) if self.has_field_end_time: self.end_time = AuxTypes.String(self._io, self, self._root) if self.has_field_is_buy_once: self.is_buy_once = self._io.read_u1() if self.has_field_precondition: self.precondition = Output.EnumShopPrecondition(self._io, self, self._root) if self.has_field_precondition_param: self.precondition_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_precondition_param_list: self.precondition_param_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_precondition_hidden: self.precondition_hidden = self._io.read_u1() if self.has_field_min_show_level: self.min_show_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_player_level: self.min_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_player_level: self.max_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_level: self.sort_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_secondary_sheet_id: self.secondary_sheet_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_choose_one_group_id: self.choose_one_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_platform_type_list: self.platform_type_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_refresh_param(self): if hasattr(self, '_m_has_field_refresh_param'): return self._m_has_field_refresh_param self._m_has_field_refresh_param = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_refresh_param', None) @property def has_field_end_time(self): if hasattr(self, '_m_has_field_end_time'): return self._m_has_field_end_time self._m_has_field_end_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_end_time', None) @property def has_field_original_price(self): if hasattr(self, '_m_has_field_original_price'): return self._m_has_field_original_price self._m_has_field_original_price = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_original_price', None) @property def has_field_discount_rate(self): if hasattr(self, '_m_has_field_discount_rate'): return self._m_has_field_discount_rate self._m_has_field_discount_rate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_discount_rate', None) @property def has_field_sub_tag_name(self): if hasattr(self, '_m_has_field_sub_tag_name'): return self._m_has_field_sub_tag_name self._m_has_field_sub_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_tag_name', None) @property def has_field_choose_one_group_id(self): if hasattr(self, '_m_has_field_choose_one_group_id'): return self._m_has_field_choose_one_group_id self._m_has_field_choose_one_group_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_choose_one_group_id', None) @property def has_field_secondary_sheet_id(self): if hasattr(self, '_m_has_field_secondary_sheet_id'): return self._m_has_field_secondary_sheet_id self._m_has_field_secondary_sheet_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_secondary_sheet_id', None) @property def has_field_min_player_level(self): if hasattr(self, '_m_has_field_min_player_level'): return self._m_has_field_min_player_level self._m_has_field_min_player_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_min_player_level', None) @property def has_field_display_days_before_sell(self): if hasattr(self, '_m_has_field_display_days_before_sell'): return self._m_has_field_display_days_before_sell self._m_has_field_display_days_before_sell = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_display_days_before_sell', None) @property def has_field_is_buy_once(self): if hasattr(self, '_m_has_field_is_buy_once'): return self._m_has_field_is_buy_once self._m_has_field_is_buy_once = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_is_buy_once', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_precondition_hidden(self): if hasattr(self, '_m_has_field_precondition_hidden'): return self._m_has_field_precondition_hidden self._m_has_field_precondition_hidden = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_precondition_hidden', None) @property def has_field_goods_id(self): if hasattr(self, '_m_has_field_goods_id'): return self._m_has_field_goods_id self._m_has_field_goods_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_goods_id', None) @property def has_field_sort_level(self): if hasattr(self, '_m_has_field_sort_level'): return self._m_has_field_sort_level self._m_has_field_sort_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_sort_level', None) @property def has_field_cost_hcoin(self): if hasattr(self, '_m_has_field_cost_hcoin'): return self._m_has_field_cost_hcoin self._m_has_field_cost_hcoin = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cost_hcoin', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_max_player_level(self): if hasattr(self, '_m_has_field_max_player_level'): return self._m_has_field_max_player_level self._m_has_field_max_player_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_max_player_level', None) @property def has_field_sub_tab_id(self): if hasattr(self, '_m_has_field_sub_tab_id'): return self._m_has_field_sub_tab_id self._m_has_field_sub_tab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sub_tab_id', None) @property def has_field_min_show_level(self): if hasattr(self, '_m_has_field_min_show_level'): return self._m_has_field_min_show_level self._m_has_field_min_show_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_min_show_level', None) @property def has_field_begin_time(self): if hasattr(self, '_m_has_field_begin_time'): return self._m_has_field_begin_time self._m_has_field_begin_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_begin_time', None) @property def has_field_item_count(self): if hasattr(self, '_m_has_field_item_count'): return self._m_has_field_item_count self._m_has_field_item_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_item_count', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_rotate_id(self): if hasattr(self, '_m_has_field_rotate_id'): return self._m_has_field_rotate_id self._m_has_field_rotate_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_rotate_id', None) @property def has_field_cost_scoin(self): if hasattr(self, '_m_has_field_cost_scoin'): return self._m_has_field_cost_scoin self._m_has_field_cost_scoin = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cost_scoin', None) @property def has_field_precondition(self): if hasattr(self, '_m_has_field_precondition'): return self._m_has_field_precondition self._m_has_field_precondition = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_precondition', None) @property def has_field_buy_limit(self): if hasattr(self, '_m_has_field_buy_limit'): return self._m_has_field_buy_limit self._m_has_field_buy_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_buy_limit', None) @property def has_field_show_id(self): if hasattr(self, '_m_has_field_show_id'): return self._m_has_field_show_id self._m_has_field_show_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_id', None) @property def has_field_refresh_type(self): if hasattr(self, '_m_has_field_refresh_type'): return self._m_has_field_refresh_type self._m_has_field_refresh_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_refresh_type', None) @property def has_field_platform_type_list(self): if hasattr(self, '_m_has_field_platform_type_list'): return self._m_has_field_platform_type_list self._m_has_field_platform_type_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_platform_type_list', None) @property def has_field_cost_mcoin(self): if hasattr(self, '_m_has_field_cost_mcoin'): return self._m_has_field_cost_mcoin self._m_has_field_cost_mcoin = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cost_mcoin', None) @property def has_field_precondition_param(self): if hasattr(self, '_m_has_field_precondition_param'): return self._m_has_field_precondition_param self._m_has_field_precondition_param = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_precondition_param', None) @property def has_field_precondition_param_list(self): if hasattr(self, '_m_has_field_precondition_param_list'): return self._m_has_field_precondition_param_list self._m_has_field_precondition_param_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_precondition_param_list', None) class AnimatorFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class DictOfEnumVolatileTypeConfigGraphicsVolatileSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumVolatileTypeConfigGraphicsVolatileSetting(self._io, self, self._root)) class ArrayOfExpeditionRewardLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ExpeditionReward(self._io, self, self._root)) class ActivityMistTrialWatcherListDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_watcher_id: self.challenge_watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_show_content_type: self.dungeon_show_content_type = Output.EnumMistTrialClientSyncType(self._io, self, self._root) if self.has_field_show_param: self.show_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_progress_format: self.progress_format = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_need_show_progress: self.is_need_show_progress = self._io.read_u1() if self.has_field_hint_format: self.hint_format = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_challenge_watcher_id(self): if hasattr(self, '_m_has_field_challenge_watcher_id'): return self._m_has_field_challenge_watcher_id self._m_has_field_challenge_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_challenge_watcher_id', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_hint_format(self): if hasattr(self, '_m_has_field_hint_format'): return self._m_has_field_hint_format self._m_has_field_hint_format = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_hint_format', None) @property def has_field_dungeon_show_content_type(self): if hasattr(self, '_m_has_field_dungeon_show_content_type'): return self._m_has_field_dungeon_show_content_type self._m_has_field_dungeon_show_content_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_show_content_type', None) @property def has_field_show_param(self): if hasattr(self, '_m_has_field_show_param'): return self._m_has_field_show_param self._m_has_field_show_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_show_param', None) @property def has_field_progress_format(self): if hasattr(self, '_m_has_field_progress_format'): return self._m_has_field_progress_format self._m_has_field_progress_format = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_progress_format', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_is_need_show_progress(self): if hasattr(self, '_m_has_field_is_need_show_progress'): return self._m_has_field_is_need_show_progress self._m_has_field_is_need_show_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_need_show_progress', None) class ActivityPotionOverallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopCgExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWall(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_collision_effect_pattern: self.collision_effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_fade_duration: self.fade_duration = self._io.read_f4le() @property def has_field_collision_effect_pattern(self): if hasattr(self, '_m_has_field_collision_effect_pattern'): return self._m_has_field_collision_effect_pattern self._m_has_field_collision_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_collision_effect_pattern', None) @property def has_field_fade_duration(self): if hasattr(self, '_m_has_field_fade_duration'): return self._m_has_field_fade_duration self._m_has_field_fade_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fade_duration', None) class ByTargetHpRatio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hp_ratio: self.hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_hp_ratio(self): if hasattr(self, '_m_has_field_hp_ratio'): return self._m_has_field_hp_ratio self._m_has_field_hp_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hp_ratio', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class SetAnimatorBool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_bool_id: self.bool_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() if self.has_field_persistent: self.persistent = self._io.read_u1() @property def has_field_bool_id(self): if hasattr(self, '_m_has_field_bool_id'): return self._m_has_field_bool_id self._m_has_field_bool_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bool_id', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_persistent(self): if hasattr(self, '_m_has_field_persistent'): return self._m_has_field_persistent self._m_has_field_persistent = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_persistent', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class BounceConjuringItemExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bg_icon_hash: self.bg_icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bg_icon_hash: self.bg_icon_hash_pre = self._io.read_s1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_bg_icon_hash(self): if hasattr(self, '_m_has_field_bg_icon_hash'): return self._m_has_field_bg_icon_hash self._m_has_field_bg_icon_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_bg_icon_hash', None) class KvpOfDictEnumEntityTokenActionTypeConfigEntityActionTokenGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumEntityTokenActionType(self._io, self, self._root) self.value = Output.ConfigEntityActionTokenGroup(self._io, self, self._root) class CombineExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigAiSkillGroupCdLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiSkillGroupCd(self._io, self, self._root)) class KvpOfDictEnumElementTypeConfigResonanceCutScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementType(self._io, self, self._root) self.value = Output.ConfigResonanceCutScene(self._io, self, self._root) class ConfigRecordEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigRecordActorBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_animator_info: self.animator_info = Output.ConfigRecordAnimatorInfo(self._io, self, self._root) if self.has_field_renderer_params: self.renderer_params = Output.ConfigRecordRendererParameters(self._io, self, self._root) if self.has_field_material_params: self.material_params = Output.ConfigRecordMaterialParameters(self._io, self, self._root) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def has_field_animator_info(self): if hasattr(self, '_m_has_field_animator_info'): return self._m_has_field_animator_info self._m_has_field_animator_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_animator_info', None) @property def serial_id(self): if hasattr(self, '_m_serial_id'): return self._m_serial_id self._m_serial_id = self.base.serial_id return getattr(self, '_m_serial_id', None) @property def has_field_renderer_params(self): if hasattr(self, '_m_has_field_renderer_params'): return self._m_has_field_renderer_params self._m_has_field_renderer_params = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_renderer_params', None) @property def scale(self): if hasattr(self, '_m_scale'): return self._m_scale self._m_scale = self.base.scale return getattr(self, '_m_scale', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_material_params(self): if hasattr(self, '_m_has_field_material_params'): return self._m_has_field_material_params self._m_has_field_material_params = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_material_params', None) class WindZoneMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shape_name: self.shape_name = AuxTypes.String(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_strength: self.strength = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_attenuation: self.attenuation = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_inner_radius: self.inner_radius = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_reverse: self.reverse = self._io.read_u1() if self.has_field_target_type: self.target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_force_growth: self.force_growth = self._io.read_f4le() if self.has_field_force_fallen: self.force_fallen = self._io.read_f4le() if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_force_type: self.force_type = Output.EnumVelocityForceType(self._io, self, self._root) if self.has_field_think_interval: self.think_interval = self._io.read_f4le() if self.has_field_on_think_interval: self.on_think_interval = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_override_weight: self.override_weight = self._io.read_f4le() @property def has_field_force_fallen(self): if hasattr(self, '_m_has_field_force_fallen'): return self._m_has_field_force_fallen self._m_has_field_force_fallen = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_force_fallen', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def has_field_force_type(self): if hasattr(self, '_m_has_field_force_type'): return self._m_has_field_force_type self._m_has_field_force_type = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_force_type', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_max_num', None) @property def has_field_shape_name(self): if hasattr(self, '_m_has_field_shape_name'): return self._m_has_field_shape_name self._m_has_field_shape_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_shape_name', None) @property def has_field_reverse(self): if hasattr(self, '_m_has_field_reverse'): return self._m_has_field_reverse self._m_has_field_reverse = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_reverse', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_strength(self): if hasattr(self, '_m_has_field_strength'): return self._m_has_field_strength self._m_has_field_strength = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_strength', None) @property def has_field_inner_radius(self): if hasattr(self, '_m_has_field_inner_radius'): return self._m_has_field_inner_radius self._m_has_field_inner_radius = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_inner_radius', None) @property def has_field_on_think_interval(self): if hasattr(self, '_m_has_field_on_think_interval'): return self._m_has_field_on_think_interval self._m_has_field_on_think_interval = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_on_think_interval', None) @property def has_field_force_growth(self): if hasattr(self, '_m_has_field_force_growth'): return self._m_has_field_force_growth self._m_has_field_force_growth = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_force_growth', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_override_weight(self): if hasattr(self, '_m_has_field_override_weight'): return self._m_has_field_override_weight self._m_has_field_override_weight = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_override_weight', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_born', None) @property def has_field_think_interval(self): if hasattr(self, '_m_has_field_think_interval'): return self._m_has_field_think_interval self._m_has_field_think_interval = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_think_interval', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiScriptedMoveToData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiScriptedMoveToData(self._io, self, self._root) class ArrayOfEnumConfigLevelPolygonTagLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumConfigLevelPolygonTag(self._io, self, self._root)) class SalesmanSpecialRewardObtainMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfActivitySumoMonsterPreviewLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ActivitySumoMonsterPreview(self._io, self, self._root)) class ConfigGuideUiMaskAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_widget_list: self.widget_list = Output.ArrayOfConfigGuideWidgetContentLengthU(self._io, self, self._root) if self.has_field_top_info: self.top_info = AuxTypes.String(self._io, self, self._root) if self.has_field_prefab_list: self.prefab_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_click_to_close: self.click_to_close = self._io.read_u1() if self.has_field_need_save: self.need_save = self._io.read_u1() if self.has_field_context_list_type: self.context_list_type = Output.EnumConfigGuideContextListType(self._io, self, self._root) if self.has_field_page_show_prefab_and_global_hint: self.page_show_prefab_and_global_hint = AuxTypes.String(self._io, self, self._root) @property def has_field_prefab_list(self): if hasattr(self, '_m_has_field_prefab_list'): return self._m_has_field_prefab_list self._m_has_field_prefab_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_prefab_list', None) @property def has_field_click_to_close(self): if hasattr(self, '_m_has_field_click_to_close'): return self._m_has_field_click_to_close self._m_has_field_click_to_close = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_click_to_close', None) @property def has_field_need_save(self): if hasattr(self, '_m_has_field_need_save'): return self._m_has_field_need_save self._m_has_field_need_save = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_need_save', None) @property def has_field_top_info(self): if hasattr(self, '_m_has_field_top_info'): return self._m_has_field_top_info self._m_has_field_top_info = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_top_info', None) @property def has_field_context_list_type(self): if hasattr(self, '_m_has_field_context_list_type'): return self._m_has_field_context_list_type self._m_has_field_context_list_type = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_context_list_type', None) @property def has_field_page_show_prefab_and_global_hint(self): if hasattr(self, '_m_has_field_page_show_prefab_and_global_hint'): return self._m_has_field_page_show_prefab_and_global_hint self._m_has_field_page_show_prefab_and_global_hint = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_page_show_prefab_and_global_hint', None) @property def has_field_widget_list(self): if hasattr(self, '_m_has_field_widget_list'): return self._m_has_field_widget_list self._m_has_field_widget_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_widget_list', None) class ConfigCameraDofAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enabled: self.enabled = self._io.read_u1() if self.has_field_focus_distance: self.focus_distance = self._io.read_f4le() if self.has_field_focus_range: self.focus_range = self._io.read_f4le() if self.has_field_near_focal_distance: self.near_focal_distance = self._io.read_f4le() if self.has_field_near_focal_trans_distance: self.near_focal_trans_distance = self._io.read_f4le() if self.has_field_dof_blur_amount: self.dof_blur_amount = self._io.read_f4le() if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_focus_range(self): if hasattr(self, '_m_has_field_focus_range'): return self._m_has_field_focus_range self._m_has_field_focus_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_focus_range', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_near_focal_trans_distance(self): if hasattr(self, '_m_has_field_near_focal_trans_distance'): return self._m_has_field_near_focal_trans_distance self._m_has_field_near_focal_trans_distance = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_near_focal_trans_distance', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_near_focal_distance(self): if hasattr(self, '_m_has_field_near_focal_distance'): return self._m_has_field_near_focal_distance self._m_has_field_near_focal_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_near_focal_distance', None) @property def has_field_dof_blur_amount(self): if hasattr(self, '_m_has_field_dof_blur_amount'): return self._m_has_field_dof_blur_amount self._m_has_field_dof_blur_amount = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_dof_blur_amount', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_quality', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_focus_distance(self): if hasattr(self, '_m_has_field_focus_distance'): return self._m_has_field_focus_distance self._m_has_field_focus_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_focus_distance', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_enabled(self): if hasattr(self, '_m_has_field_enabled'): return self._m_has_field_enabled self._m_has_field_enabled = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enabled', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiLandingData(self._io, self, self._root) class ContextConditionQuestGlobalVar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_quest_global_var_id: self.quest_global_var_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_quest_global_var_id(self): if hasattr(self, '_m_has_field_quest_global_var_id'): return self._m_has_field_quest_global_var_id self._m_has_field_quest_global_var_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_global_var_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class KvpOfDictAuxTypesVlqBase128LeUConfigPreload(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigPreload(self._io, self, self._root) class ActivitySpiceGivingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_giving_data_id: self.giving_data_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_character_id: self.character_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_giving_data_id(self): if hasattr(self, '_m_has_field_giving_data_id'): return self._m_has_field_giving_data_id self._m_has_field_giving_data_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_giving_data_id', None) @property def has_field_character_id(self): if hasattr(self, '_m_has_field_character_id'): return self._m_has_field_character_id self._m_has_field_character_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_character_id', None) class ConfigGadgetStateEnableGadgetIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class ConfigAudioEmitterOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioOperation(self._io, self, self._root) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class ConfigCharacter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEntity(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_combat: self.combat = Output.ConfigCombat(self._io, self, self._root) if self.has_field_equip_controller: self.equip_controller = Output.ConfigEquipController(self._io, self, self._root) if self.has_field_sub_equip_controllers: self.sub_equip_controllers = Output.ArrayOfConfigSubEquipControllerLengthU(self._io, self, self._root) if self.has_field_abilities: self.abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_state_layers: self.state_layers = Output.DictOfAuxTypesStringDispConfigBaseStateLayer(self._io, self, self._root) if self.has_field_face: self.face = Output.ConfigFace(self._io, self, self._root) if self.has_field_part_control: self.part_control = Output.ConfigPartController(self._io, self, self._root) if self.has_field_billboard: self.billboard = Output.DispConfigBillboard(self._io, self, self._root) if self.has_field_bind_emotions: self.bind_emotions = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def has_field_face(self): if hasattr(self, '_m_has_field_face'): return self._m_has_field_face self._m_has_field_face = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_face', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_combat(self): if hasattr(self, '_m_has_field_combat'): return self._m_has_field_combat self._m_has_field_combat = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_combat', None) @property def has_field_abilities(self): if hasattr(self, '_m_has_field_abilities'): return self._m_has_field_abilities self._m_has_field_abilities = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_abilities', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def has_field_billboard(self): if hasattr(self, '_m_has_field_billboard'): return self._m_has_field_billboard self._m_has_field_billboard = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_billboard', None) @property def has_field_state_layers(self): if hasattr(self, '_m_has_field_state_layers'): return self._m_has_field_state_layers self._m_has_field_state_layers = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_state_layers', None) @property def has_field_sub_equip_controllers(self): if hasattr(self, '_m_has_field_sub_equip_controllers'): return self._m_has_field_sub_equip_controllers self._m_has_field_sub_equip_controllers = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_sub_equip_controllers', None) @property def has_field_bind_emotions(self): if hasattr(self, '_m_has_field_bind_emotions'): return self._m_has_field_bind_emotions self._m_has_field_bind_emotions = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_bind_emotions', None) @property def has_field_equip_controller(self): if hasattr(self, '_m_has_field_equip_controller'): return self._m_has_field_equip_controller self._m_has_field_equip_controller = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_equip_controller', None) @property def has_field_part_control(self): if hasattr(self, '_m_has_field_part_control'): return self._m_has_field_part_control self._m_has_field_part_control = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_part_control', None) class EnumMarkVisibilityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkVisibilityType, self.data.value) return getattr(self, '_m_value', None) class EnumHuntingCluePointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingCluePointType, self.data.value) return getattr(self, '_m_value', None) class CustomGadgetCameraSettings(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gadget_height: self.gadget_height = self._io.read_f4le() if self.has_field_min_camera_radius: self.min_camera_radius = self._io.read_f4le() if self.has_field_min_elevation: self.min_elevation = self._io.read_f4le() if self.has_field_leftright_shift: self.leftright_shift = self._io.read_f4le() if self.has_field_up_down_shift: self.up_down_shift = self._io.read_f4le() @property def has_field_leftright_shift(self): if hasattr(self, '_m_has_field_leftright_shift'): return self._m_has_field_leftright_shift self._m_has_field_leftright_shift = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_leftright_shift', None) @property def has_field_min_elevation(self): if hasattr(self, '_m_has_field_min_elevation'): return self._m_has_field_min_elevation self._m_has_field_min_elevation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_elevation', None) @property def has_field_gadget_height(self): if hasattr(self, '_m_has_field_gadget_height'): return self._m_has_field_gadget_height self._m_has_field_gadget_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_height', None) @property def has_field_min_camera_radius(self): if hasattr(self, '_m_has_field_min_camera_radius'): return self._m_has_field_min_camera_radius self._m_has_field_min_camera_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_camera_radius', None) @property def has_field_up_down_shift(self): if hasattr(self, '_m_has_field_up_down_shift'): return self._m_has_field_up_down_shift self._m_has_field_up_down_shift = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_up_down_shift', None) class ArrayOfEnumJsonClimateTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumJsonClimateType(self._io, self, self._root)) class ChatExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumUniqueModifierCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UniqueModifierCond, self.data.value) return getattr(self, '_m_value', None) class DraftTextDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRoundRandomType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoundRandomType, self.data.value) return getattr(self, '_m_value', None) class EnumInterruptButtonType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InterruptButtonType, self.data.value) return getattr(self, '_m_value', None) class EnumReunionPrivilegeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReunionPrivilegeType, self.data.value) return getattr(self, '_m_value', None) class RadarHintExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SeaLampSectionMainQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiSensingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sensitivity: self.sensitivity = self._io.read_f4le() if self.has_field_enable_vision: self.enable_vision = self._io.read_u1() if self.has_field_view_range: self.view_range = self._io.read_f4le() if self.has_field_view_panoramic: self.view_panoramic = self._io.read_u1() if self.has_field_horizontal_fov: self.horizontal_fov = self._io.read_f4le() if self.has_field_vertical_fov: self.vertical_fov = self._io.read_f4le() if self.has_field_use_eye_transform_rotation: self.use_eye_transform_rotation = self._io.read_u1() if self.has_field_hear_attraction_range: self.hear_attraction_range = self._io.read_f4le() if self.has_field_hear_footstep_range: self.hear_footstep_range = self._io.read_f4le() if self.has_field_feel_range: self.feel_range = self._io.read_f4le() if self.has_field_sourceless_hit_attraction_range: self.sourceless_hit_attraction_range = self._io.read_f4le() @property def has_field_sensitivity(self): if hasattr(self, '_m_has_field_sensitivity'): return self._m_has_field_sensitivity self._m_has_field_sensitivity = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_sensitivity', None) @property def has_field_hear_footstep_range(self): if hasattr(self, '_m_has_field_hear_footstep_range'): return self._m_has_field_hear_footstep_range self._m_has_field_hear_footstep_range = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_hear_footstep_range', None) @property def has_field_enable_vision(self): if hasattr(self, '_m_has_field_enable_vision'): return self._m_has_field_enable_vision self._m_has_field_enable_vision = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_enable_vision', None) @property def has_field_hear_attraction_range(self): if hasattr(self, '_m_has_field_hear_attraction_range'): return self._m_has_field_hear_attraction_range self._m_has_field_hear_attraction_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_hear_attraction_range', None) @property def has_field_sourceless_hit_attraction_range(self): if hasattr(self, '_m_has_field_sourceless_hit_attraction_range'): return self._m_has_field_sourceless_hit_attraction_range self._m_has_field_sourceless_hit_attraction_range = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_sourceless_hit_attraction_range', None) @property def has_field_feel_range(self): if hasattr(self, '_m_has_field_feel_range'): return self._m_has_field_feel_range self._m_has_field_feel_range = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_feel_range', None) @property def has_field_horizontal_fov(self): if hasattr(self, '_m_has_field_horizontal_fov'): return self._m_has_field_horizontal_fov self._m_has_field_horizontal_fov = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_horizontal_fov', None) @property def has_field_view_range(self): if hasattr(self, '_m_has_field_view_range'): return self._m_has_field_view_range self._m_has_field_view_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_view_range', None) @property def has_field_view_panoramic(self): if hasattr(self, '_m_has_field_view_panoramic'): return self._m_has_field_view_panoramic self._m_has_field_view_panoramic = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_view_panoramic', None) @property def has_field_vertical_fov(self): if hasattr(self, '_m_has_field_vertical_fov'): return self._m_has_field_vertical_fov self._m_has_field_vertical_fov = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_vertical_fov', None) @property def has_field_use_eye_transform_rotation(self): if hasattr(self, '_m_has_field_use_eye_transform_rotation'): return self._m_has_field_use_eye_transform_rotation self._m_has_field_use_eye_transform_rotation = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_use_eye_transform_rotation', None) class ProudLifeEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExclusiveRuleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExclusiveRuleType, self.data.value) return getattr(self, '_m_value', None) class FetterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthU(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthU(self._io, self, self._root) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_open_conds', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_finish_conds', None) class ChangeColliderSurface(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_transform_name: self.transform_name = AuxTypes.String(self._io, self, self._root) if self.has_field_surface_type: self.surface_type = Output.EnumSceneSurfaceType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_transform_name(self): if hasattr(self, '_m_has_field_transform_name'): return self._m_has_field_transform_name self._m_has_field_transform_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_transform_name', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_surface_type(self): if hasattr(self, '_m_has_field_surface_type'): return self._m_has_field_surface_type self._m_has_field_surface_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_surface_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigTalkSchemeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigTalkScheme(self._io, self, self._root)) class MechanicusGearLevelUpExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumElementTypeConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementTypeConfigWwiseString(self._io, self, self._root)) class AudioPlatformMoveSettingsUsagePair(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_id: self.entity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_settings_id: self.settings_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_entity_id(self): if hasattr(self, '_m_has_field_entity_id'): return self._m_has_field_entity_id self._m_has_field_entity_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_id', None) @property def has_field_settings_id(self): if hasattr(self, '_m_has_field_settings_id'): return self._m_has_field_settings_id self._m_has_field_settings_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_settings_id', None) class EnumAnimalCodexSubType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimalCodexSubType, self.data.value) return getattr(self, '_m_value', None) class MechanicusWatcherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_tokens: self.reward_tokens = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_reward_tokens(self): if hasattr(self, '_m_has_field_reward_tokens'): return self._m_has_field_reward_tokens self._m_has_field_reward_tokens = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_tokens', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ConfigQteStepCondActionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cond_group: self.cond_group = Output.ConfigQteStepCondGroup(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigQteStepBaseActionLengthU(self._io, self, self._root) @property def has_field_cond_group(self): if hasattr(self, '_m_has_field_cond_group'): return self._m_has_field_cond_group self._m_has_field_cond_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cond_group', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) class ArrayOfConfigKeyInputLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigKeyInput(self._io, self, self._root)) class ArrayOfConfigBattleFervorUpdateTriggerByMonsterLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigBattleFervorUpdateTriggerByMonster(self._io, self, self._root)) class DigStageDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_unlock_id: self.quest_unlock_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_unlock_id: self.stage_unlock_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_title: self.quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_time: self.unlock_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_stage_unlock_id(self): if hasattr(self, '_m_has_field_stage_unlock_id'): return self._m_has_field_stage_unlock_id self._m_has_field_stage_unlock_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stage_unlock_id', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_quest_title(self): if hasattr(self, '_m_has_field_quest_title'): return self._m_has_field_quest_title self._m_has_field_quest_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_title', None) @property def has_field_quest_unlock_id(self): if hasattr(self, '_m_has_field_quest_unlock_id'): return self._m_has_field_quest_unlock_id self._m_has_field_quest_unlock_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_unlock_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_unlock_time(self): if hasattr(self, '_m_has_field_unlock_time'): return self._m_has_field_unlock_time self._m_has_field_unlock_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_time', None) class EnumItemUseTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemUseTarget, self.data.value) return getattr(self, '_m_value', None) class EnumDailyTaskActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DailyTaskActionType, self.data.value) return getattr(self, '_m_value', None) class ConfigBaseShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_use_height: self.use_height = self._io.read_u1() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_height_type: self.height_type = Output.EnumHeightPosType(self._io, self, self._root) @property def has_field_use_height(self): if hasattr(self, '_m_has_field_use_height'): return self._m_has_field_use_height self._m_has_field_use_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_height', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_height_type(self): if hasattr(self, '_m_has_field_height_type'): return self._m_has_field_height_type self._m_has_field_height_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_height_type', None) class KvpOfDictEnumStrikeTypeConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumStrikeType(self._io, self, self._root) self.value = Output.ConfigWwiseString(self._io, self, self._root) class ConfigMusicUInt32condition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class TouchpadFocusAccelerationSigmoidPara(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_phase: self.phase = self._io.read_f4le() if self.has_field_slope: self.slope = self._io.read_f4le() if self.has_field_amplitude: self.amplitude = self._io.read_f4le() if self.has_field_clip: self.clip = self._io.read_f4le() @property def has_field_phase(self): if hasattr(self, '_m_has_field_phase'): return self._m_has_field_phase self._m_has_field_phase = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_phase', None) @property def has_field_slope(self): if hasattr(self, '_m_has_field_slope'): return self._m_has_field_slope self._m_has_field_slope = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_slope', None) @property def has_field_amplitude(self): if hasattr(self, '_m_has_field_amplitude'): return self._m_has_field_amplitude self._m_has_field_amplitude = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_amplitude', None) @property def has_field_clip(self): if hasattr(self, '_m_has_field_clip'): return self._m_has_field_clip self._m_has_field_clip = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_clip', None) class ConfigGuideOpenPaimonNavigationCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumBartenderEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BartenderEffectType, self.data.value) return getattr(self, '_m_value', None) class RegionSearchCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRegionSearchCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class PersonalLineExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_quest_id: self.start_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_start_time: self.start_time = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_start_quest_id(self): if hasattr(self, '_m_has_field_start_quest_id'): return self._m_has_field_start_quest_id self._m_has_field_start_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_start_quest_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) @property def has_field_start_time(self): if hasattr(self, '_m_has_field_start_time'): return self._m_has_field_start_time self._m_has_field_start_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_start_time', None) class OfferingLumenStoneExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfNumberItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberItemOverrideInfo(self._io, self, self._root)) class ArrayOfTowerConditionLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TowerCondition(self._io, self, self._root)) class PhotographExpressionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_emotion_name: self.emotion_name = AuxTypes.String(self._io, self, self._root) if self.has_field_phoneme_name: self.phoneme_name = AuxTypes.String(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_emotion_description: self.emotion_description = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_desc: self.unlock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_phoneme_name(self): if hasattr(self, '_m_has_field_phoneme_name'): return self._m_has_field_phoneme_name self._m_has_field_phoneme_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_phoneme_name', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_unlock_desc(self): if hasattr(self, '_m_has_field_unlock_desc'): return self._m_has_field_unlock_desc self._m_has_field_unlock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_desc', None) @property def has_field_emotion_name(self): if hasattr(self, '_m_has_field_emotion_name'): return self._m_has_field_emotion_name self._m_has_field_emotion_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_emotion_name', None) @property def has_field_emotion_description(self): if hasattr(self, '_m_has_field_emotion_description'): return self._m_has_field_emotion_description self._m_has_field_emotion_description = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_emotion_description', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_finish_conds', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) class ExhibitionListExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopSpecialKeysDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGachaBaseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NpcFirstMetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableAfterImage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_index', None) class BySceneLoaded(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class KvpOfDictAuxTypesStringConfigAiSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAiSkill(self._io, self, self._root) class ReputationRequestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_normal_map_id: self.normal_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hard_map_id: self.hard_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_hard_score: self.unlock_hard_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_unlock_hard_score(self): if hasattr(self, '_m_has_field_unlock_hard_score'): return self._m_has_field_unlock_hard_score self._m_has_field_unlock_hard_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_hard_score', None) @property def has_field_normal_map_id(self): if hasattr(self, '_m_has_field_normal_map_id'): return self._m_has_field_normal_map_id self._m_has_field_normal_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_normal_map_id', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_hard_map_id(self): if hasattr(self, '_m_has_field_hard_map_id'): return self._m_has_field_hard_map_id self._m_has_field_hard_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hard_map_id', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_watcher_list', None) class BartenderTaskExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GetHealAmountToGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumGlobalValueChangeType(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RogueDiaryRoundRoomExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hard_room_count: self.hard_room_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_type_config_list: self.room_type_config_list = Output.ArrayOfRogueDiaryRoomTypeConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hard_room_count(self): if hasattr(self, '_m_has_field_hard_room_count'): return self._m_has_field_hard_room_count self._m_has_field_hard_room_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hard_room_count', None) @property def has_field_room_type_config_list(self): if hasattr(self, '_m_has_field_room_type_config_list'): return self._m_has_field_room_type_config_list self._m_has_field_room_type_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_room_type_config_list', None) class ConfigDialogNextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_talk_id: self.talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_id', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class MonsterRelationshipExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_str: self.tag_str = AuxTypes.String(self._io, self, self._root) if self.has_field_monster_rarity: self.monster_rarity = Output.EnumMonsterRarityType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_tag_str(self): if hasattr(self, '_m_has_field_tag_str'): return self._m_has_field_tag_str self._m_has_field_tag_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tag_str', None) @property def has_field_monster_rarity(self): if hasattr(self, '_m_has_field_monster_rarity'): return self._m_has_field_monster_rarity self._m_has_field_monster_rarity = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_monster_rarity', None) class TowerCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tower_cond_type: self.tower_cond_type = Output.EnumTowerCondType(self._io, self, self._root) if self.has_field_argument_list_upper: self.argument_list_upper = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_argument_list: self.argument_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_tower_cond_type(self): if hasattr(self, '_m_has_field_tower_cond_type'): return self._m_has_field_tower_cond_type self._m_has_field_tower_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tower_cond_type', None) @property def has_field_argument_list_upper(self): if hasattr(self, '_m_has_field_argument_list_upper'): return self._m_has_field_argument_list_upper self._m_has_field_argument_list_upper = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_argument_list_upper', None) @property def has_field_argument_list(self): if hasattr(self, '_m_has_field_argument_list'): return self._m_has_field_argument_list self._m_has_field_argument_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_argument_list', None) class ConfigIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_use_trigger: self.use_trigger = self._io.read_u1() if self.has_field_use_interaction_trigger: self.use_interaction_trigger = self._io.read_u1() if self.has_field_use_push_collider: self.use_push_collider = self._io.read_u1() if self.has_field_use_head_control_trigger: self.use_head_control_trigger = self._io.read_u1() if self.has_field_trigger_radius: self.trigger_radius = self._io.read_f4le() if self.has_field_trigger_height: self.trigger_height = self._io.read_f4le() if self.has_field_interaction_trigger_radius: self.interaction_trigger_radius = self._io.read_f4le() if self.has_field_head_ctrl_radius: self.head_ctrl_radius = self._io.read_f4le() if self.has_field_trigger_offset: self.trigger_offset = Output.Vector(self._io, self, self._root) @property def has_field_trigger_radius(self): if hasattr(self, '_m_has_field_trigger_radius'): return self._m_has_field_trigger_radius self._m_has_field_trigger_radius = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_trigger_radius', None) @property def has_field_head_ctrl_radius(self): if hasattr(self, '_m_has_field_head_ctrl_radius'): return self._m_has_field_head_ctrl_radius self._m_has_field_head_ctrl_radius = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_head_ctrl_radius', None) @property def has_field_interaction_trigger_radius(self): if hasattr(self, '_m_has_field_interaction_trigger_radius'): return self._m_has_field_interaction_trigger_radius self._m_has_field_interaction_trigger_radius = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_interaction_trigger_radius', None) @property def has_field_trigger_height(self): if hasattr(self, '_m_has_field_trigger_height'): return self._m_has_field_trigger_height self._m_has_field_trigger_height = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_trigger_height', None) @property def has_field_use_interaction_trigger(self): if hasattr(self, '_m_has_field_use_interaction_trigger'): return self._m_has_field_use_interaction_trigger self._m_has_field_use_interaction_trigger = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_use_interaction_trigger', None) @property def has_field_use_head_control_trigger(self): if hasattr(self, '_m_has_field_use_head_control_trigger'): return self._m_has_field_use_head_control_trigger self._m_has_field_use_head_control_trigger = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_use_head_control_trigger', None) @property def has_field_use_push_collider(self): if hasattr(self, '_m_has_field_use_push_collider'): return self._m_has_field_use_push_collider self._m_has_field_use_push_collider = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_use_push_collider', None) @property def has_field_trigger_offset(self): if hasattr(self, '_m_has_field_trigger_offset'): return self._m_has_field_trigger_offset self._m_has_field_trigger_offset = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_trigger_offset', None) @property def has_field_use_trigger(self): if hasattr(self, '_m_has_field_use_trigger'): return self._m_has_field_use_trigger self._m_has_field_use_trigger = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_use_trigger', None) class DungeonEntrySatisfiedCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDungeonEntrySatisfiedConditionType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class CreateMovingPlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.CreateGadget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_route_id: self.route_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detect_height: self.detect_height = self._io.read_f4le() if self.has_field_detect_width: self.detect_width = self._io.read_f4le() if self.has_field_enable_rotation_offset: self.enable_rotation_offset = self._io.read_u1() if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_route_id(self): if hasattr(self, '_m_has_field_route_id'): return self._m_has_field_route_id self._m_has_field_route_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_route_id', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def camp_id(self): if hasattr(self, '_m_camp_id'): return self._m_camp_id self._m_camp_id = self.base.camp_id return getattr(self, '_m_camp_id', None) @property def owner_is_target(self): if hasattr(self, '_m_owner_is_target'): return self._m_owner_is_target self._m_owner_is_target = self.base.owner_is_target return getattr(self, '_m_owner_is_target', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_fail_actions', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_detect_height(self): if hasattr(self, '_m_has_field_detect_height'): return self._m_has_field_detect_height self._m_has_field_detect_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_height', None) @property def sight_group_with_owner(self): if hasattr(self, '_m_sight_group_with_owner'): return self._m_sight_group_with_owner self._m_sight_group_with_owner = self.base.sight_group_with_owner return getattr(self, '_m_sight_group_with_owner', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def camp_target_type(self): if hasattr(self, '_m_camp_target_type'): return self._m_camp_target_type self._m_camp_target_type = self.base.camp_target_type return getattr(self, '_m_camp_target_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def life_by_owner_is_alive(self): if hasattr(self, '_m_life_by_owner_is_alive'): return self._m_life_by_owner_is_alive self._m_life_by_owner_is_alive = self.base.life_by_owner_is_alive return getattr(self, '_m_life_by_owner_is_alive', None) @property def life_by_owner_v2(self): if hasattr(self, '_m_life_by_owner_v2'): return self._m_life_by_owner_v2 self._m_life_by_owner_v2 = self.base.life_by_owner_v2 return getattr(self, '_m_life_by_owner_v2', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def is_peer_id_from_player(self): if hasattr(self, '_m_is_peer_id_from_player'): return self._m_is_peer_id_from_player self._m_is_peer_id_from_player = self.base.is_peer_id_from_player return getattr(self, '_m_is_peer_id_from_player', None) @property def dont_kill_self_by_client_prediction(self): if hasattr(self, '_m_dont_kill_self_by_client_prediction'): return self._m_dont_kill_self_by_client_prediction self._m_dont_kill_self_by_client_prediction = self.base.dont_kill_self_by_client_prediction return getattr(self, '_m_dont_kill_self_by_client_prediction', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def prop_owner_is(self): if hasattr(self, '_m_prop_owner_is'): return self._m_prop_owner_is self._m_prop_owner_is = self.base.prop_owner_is return getattr(self, '_m_prop_owner_is', None) @property def has_field_detect_width(self): if hasattr(self, '_m_has_field_detect_width'): return self._m_has_field_detect_width self._m_has_field_detect_width = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_detect_width', None) @property def by_server(self): if hasattr(self, '_m_by_server'): return self._m_by_server self._m_by_server = self.base.by_server return getattr(self, '_m_by_server', None) @property def owner_is(self): if hasattr(self, '_m_owner_is'): return self._m_owner_is self._m_owner_is = self.base.owner_is return getattr(self, '_m_owner_is', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_enable_rotation_offset(self): if hasattr(self, '_m_has_field_enable_rotation_offset'): return self._m_has_field_enable_rotation_offset self._m_has_field_enable_rotation_offset = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enable_rotation_offset', None) @property def check_ground(self): if hasattr(self, '_m_check_ground'): return self._m_check_ground self._m_check_ground = self.base.check_ground return getattr(self, '_m_check_ground', None) class FightPropTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IndicatorLogic(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_i_operator: self.i_operator = Output.EnumIndicatorOperator(self._io, self, self._root) if self.has_field_i_conditions: self.i_conditions = Output.ArrayOfDispIndicatorConditionLengthU(self._io, self, self._root) @property def has_field_i_operator(self): if hasattr(self, '_m_has_field_i_operator'): return self._m_has_field_i_operator self._m_has_field_i_operator = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_i_operator', None) @property def has_field_i_conditions(self): if hasattr(self, '_m_has_field_i_conditions'): return self._m_has_field_i_conditions self._m_has_field_i_conditions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_i_conditions', None) class IrodoriChessGearExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_gear_id: self.gear_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_enable_rotate: self.is_enable_rotate = self._io.read_u1() if self.has_field_init_level: self.init_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_name: self.gear_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_short_name: self.gear_short_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_icon_path: self.gear_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tag_icon_path: self.tag_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_map_icon_path: self.map_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_attack: self.attack = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_mastery: self.mastery = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_attack_speed: self.attack_speed = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_attack_range: self.attack_range = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_is_enable_rotate(self): if hasattr(self, '_m_has_field_is_enable_rotate'): return self._m_has_field_is_enable_rotate self._m_has_field_is_enable_rotate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_enable_rotate', None) @property def has_field_attack_speed(self): if hasattr(self, '_m_has_field_attack_speed'): return self._m_has_field_attack_speed self._m_has_field_attack_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_attack_speed', None) @property def has_field_attack(self): if hasattr(self, '_m_has_field_attack'): return self._m_has_field_attack self._m_has_field_attack = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_attack', None) @property def has_field_attack_range(self): if hasattr(self, '_m_has_field_attack_range'): return self._m_has_field_attack_range self._m_has_field_attack_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_attack_range', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gear_name(self): if hasattr(self, '_m_has_field_gear_name'): return self._m_has_field_gear_name self._m_has_field_gear_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gear_name', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_gear_short_name(self): if hasattr(self, '_m_has_field_gear_short_name'): return self._m_has_field_gear_short_name self._m_has_field_gear_short_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_gear_short_name', None) @property def has_field_gear_icon_path(self): if hasattr(self, '_m_has_field_gear_icon_path'): return self._m_has_field_gear_icon_path self._m_has_field_gear_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_gear_icon_path', None) @property def has_field_init_level(self): if hasattr(self, '_m_has_field_init_level'): return self._m_has_field_init_level self._m_has_field_init_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_init_level', None) @property def has_field_mastery(self): if hasattr(self, '_m_has_field_mastery'): return self._m_has_field_mastery self._m_has_field_mastery = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_mastery', None) @property def has_field_tag_icon_path(self): if hasattr(self, '_m_has_field_tag_icon_path'): return self._m_has_field_tag_icon_path self._m_has_field_tag_icon_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_tag_icon_path', None) @property def has_field_map_icon_path(self): if hasattr(self, '_m_has_field_map_icon_path'): return self._m_has_field_map_icon_path self._m_has_field_map_icon_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_map_icon_path', None) @property def has_field_gear_id(self): if hasattr(self, '_m_has_field_gear_id'): return self._m_has_field_gear_id self._m_has_field_gear_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_gear_id', None) class QteStepButtonInputTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigJob(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigJob(self._io, self, self._root) class DictOfAuxTypesVlqBase128LeUDispConfigJudgeNodeBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUDispConfigJudgeNodeBase(self._io, self, self._root)) class ArrayOfFlightDailyInfoLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FlightDailyInfo(self._io, self, self._root)) class ContextConditionChapterQuestState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumQuestState(self._io, self, self._root) if self.has_field_start_or_end_quest: self.start_or_end_quest = self._io.read_u1() @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state', None) @property def has_field_start_or_end_quest(self): if hasattr(self, '_m_has_field_start_or_end_quest'): return self._m_has_field_start_or_end_quest self._m_has_field_start_or_end_quest = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_start_or_end_quest', None) class ByHasTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tag: self.tag = AuxTypes.String(self._io, self, self._root) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tag', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ContextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConstValueExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPlatformMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_avatar_trigger_event_distance: self.avatar_trigger_event_distance = self._io.read_f4le() if self.has_field_is_moving_water: self.is_moving_water = self._io.read_u1() if self.has_field_calc_move_state_in_tick: self.calc_move_state_in_tick = self._io.read_u1() if self.has_field_route: self.route = Output.ConfigRoute(self._io, self, self._root) if self.has_field_delay_type: self.delay_type = Output.EnumMovePlatformDelayType(self._io, self, self._root) @property def has_field_is_moving_water(self): if hasattr(self, '_m_has_field_is_moving_water'): return self._m_has_field_is_moving_water self._m_has_field_is_moving_water = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_moving_water', None) @property def has_field_delay_type(self): if hasattr(self, '_m_has_field_delay_type'): return self._m_has_field_delay_type self._m_has_field_delay_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_delay_type', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_calc_move_state_in_tick(self): if hasattr(self, '_m_has_field_calc_move_state_in_tick'): return self._m_has_field_calc_move_state_in_tick self._m_has_field_calc_move_state_in_tick = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_calc_move_state_in_tick', None) @property def has_field_avatar_trigger_event_distance(self): if hasattr(self, '_m_has_field_avatar_trigger_event_distance'): return self._m_has_field_avatar_trigger_event_distance self._m_has_field_avatar_trigger_event_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_avatar_trigger_event_distance', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_route(self): if hasattr(self, '_m_has_field_route'): return self._m_has_field_route self._m_has_field_route = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_route', None) class ProductPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalValues(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_first_person_coop_cam_configs: self.first_person_coop_cam_configs = Output.DictOfEnumNpcBodyTypeFirstPersonCoopCamConfig(self._io, self, self._root) if self.has_field_gadget_ui_item_group_show_conds_configs: self.gadget_ui_item_group_show_conds_configs = Output.DictOfAuxTypesStringArrayOfConfigGadgetUiItemGroupShowCondLengthU(self._io, self, self._root) if self.has_field_special_element_view_esl_value: self.special_element_view_esl_value = self._io.read_f4le() @property def has_field_first_person_coop_cam_configs(self): if hasattr(self, '_m_has_field_first_person_coop_cam_configs'): return self._m_has_field_first_person_coop_cam_configs self._m_has_field_first_person_coop_cam_configs = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_first_person_coop_cam_configs', None) @property def has_field_gadget_ui_item_group_show_conds_configs(self): if hasattr(self, '_m_has_field_gadget_ui_item_group_show_conds_configs'): return self._m_has_field_gadget_ui_item_group_show_conds_configs self._m_has_field_gadget_ui_item_group_show_conds_configs = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadget_ui_item_group_show_conds_configs', None) @property def has_field_special_element_view_esl_value(self): if hasattr(self, '_m_has_field_special_element_view_esl_value'): return self._m_has_field_special_element_view_esl_value self._m_has_field_special_element_view_esl_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_special_element_view_esl_value', None) class EnumMusicKeyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MusicKeyType, self.data.value) return getattr(self, '_m_value', None) class ByPlayerClimateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActivityPhotographPosExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos_title: self.pos_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_require_title_in_activity_page: self.require_title_in_activity_page = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_require_desc_in_activity_page: self.require_desc_in_activity_page = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_invite_desc: self.npc_invite_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_comment_desc: self.npc_comment_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pic_small: self.pic_small = AuxTypes.String(self._io, self, self._root) if self.has_field_pic_big: self.pic_big = AuxTypes.String(self._io, self, self._root) if self.has_field_photo_check_root_id: self.photo_check_root_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_root_node_desc: self.root_node_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_photo_check_sub_node_id: self.photo_check_sub_node_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_photo_check_sub_node_desc: self.photo_check_sub_node_desc = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_red_point_id: self.red_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_pic_big(self): if hasattr(self, '_m_has_field_pic_big'): return self._m_has_field_pic_big self._m_has_field_pic_big = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_pic_big', None) @property def has_field_root_node_desc(self): if hasattr(self, '_m_has_field_root_node_desc'): return self._m_has_field_root_node_desc self._m_has_field_root_node_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_root_node_desc', None) @property def has_field_require_desc_in_activity_page(self): if hasattr(self, '_m_has_field_require_desc_in_activity_page'): return self._m_has_field_require_desc_in_activity_page self._m_has_field_require_desc_in_activity_page = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_require_desc_in_activity_page', None) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_npc_comment_desc(self): if hasattr(self, '_m_has_field_npc_comment_desc'): return self._m_has_field_npc_comment_desc self._m_has_field_npc_comment_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_npc_comment_desc', None) @property def has_field_red_point_id(self): if hasattr(self, '_m_has_field_red_point_id'): return self._m_has_field_red_point_id self._m_has_field_red_point_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_red_point_id', None) @property def has_field_pos_title(self): if hasattr(self, '_m_has_field_pos_title'): return self._m_has_field_pos_title self._m_has_field_pos_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pos_title', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_pic_small(self): if hasattr(self, '_m_has_field_pic_small'): return self._m_has_field_pic_small self._m_has_field_pic_small = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pic_small', None) @property def has_field_photo_check_sub_node_id(self): if hasattr(self, '_m_has_field_photo_check_sub_node_id'): return self._m_has_field_photo_check_sub_node_id self._m_has_field_photo_check_sub_node_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_photo_check_sub_node_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_photo_check_root_id(self): if hasattr(self, '_m_has_field_photo_check_root_id'): return self._m_has_field_photo_check_root_id self._m_has_field_photo_check_root_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_photo_check_root_id', None) @property def has_field_photo_check_sub_node_desc(self): if hasattr(self, '_m_has_field_photo_check_sub_node_desc'): return self._m_has_field_photo_check_sub_node_desc self._m_has_field_photo_check_sub_node_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_photo_check_sub_node_desc', None) @property def has_field_require_title_in_activity_page(self): if hasattr(self, '_m_has_field_require_title_in_activity_page'): return self._m_has_field_require_title_in_activity_page self._m_has_field_require_title_in_activity_page = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_require_title_in_activity_page', None) @property def has_field_npc_invite_desc(self): if hasattr(self, '_m_has_field_npc_invite_desc'): return self._m_has_field_npc_invite_desc self._m_has_field_npc_invite_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_npc_invite_desc', None) class DungeonEntryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRoguelikeCardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoguelikeCardType, self.data.value) return getattr(self, '_m_value', None) class EnumAbilityState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityState, self.data.value) return getattr(self, '_m_value', None) class MichiaePreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro_title: self.intro_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro_content: self.intro_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_group_bundle_id: self.boss_group_bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radar_search_radius: self.radar_search_radius = self._io.read_f4le() if self.has_field_radar_remove_radius: self.radar_remove_radius = self._io.read_f4le() if self.has_field_all_radar_show_limit: self.all_radar_show_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_sub_quest_id: self.pre_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_activity_quest_id: self.pre_activity_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_quest_id: self.activity_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id_map: self.pre_quest_id_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id_list: self.pre_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_pre_quest_id_list(self): if hasattr(self, '_m_has_field_pre_quest_id_list'): return self._m_has_field_pre_quest_id_list self._m_has_field_pre_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_pre_quest_id_list', None) @property def has_field_radar_remove_radius(self): if hasattr(self, '_m_has_field_radar_remove_radius'): return self._m_has_field_radar_remove_radius self._m_has_field_radar_remove_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_radar_remove_radius', None) @property def has_field_pre_quest_id_map(self): if hasattr(self, '_m_has_field_pre_quest_id_map'): return self._m_has_field_pre_quest_id_map self._m_has_field_pre_quest_id_map = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest_id_map', None) @property def has_field_intro_title(self): if hasattr(self, '_m_has_field_intro_title'): return self._m_has_field_intro_title self._m_has_field_intro_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_intro_title', None) @property def has_field_boss_group_bundle_id(self): if hasattr(self, '_m_has_field_boss_group_bundle_id'): return self._m_has_field_boss_group_bundle_id self._m_has_field_boss_group_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_boss_group_bundle_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_radar_search_radius(self): if hasattr(self, '_m_has_field_radar_search_radius'): return self._m_has_field_radar_search_radius self._m_has_field_radar_search_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_radar_search_radius', None) @property def has_field_activity_quest_id(self): if hasattr(self, '_m_has_field_activity_quest_id'): return self._m_has_field_activity_quest_id self._m_has_field_activity_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_activity_quest_id', None) @property def has_field_intro_content(self): if hasattr(self, '_m_has_field_intro_content'): return self._m_has_field_intro_content self._m_has_field_intro_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_intro_content', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_all_radar_show_limit(self): if hasattr(self, '_m_has_field_all_radar_show_limit'): return self._m_has_field_all_radar_show_limit self._m_has_field_all_radar_show_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_all_radar_show_limit', None) @property def has_field_pre_sub_quest_id(self): if hasattr(self, '_m_has_field_pre_sub_quest_id'): return self._m_has_field_pre_sub_quest_id self._m_has_field_pre_sub_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_pre_sub_quest_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_pre_activity_quest_id(self): if hasattr(self, '_m_has_field_pre_activity_quest_id'): return self._m_has_field_pre_activity_quest_id self._m_has_field_pre_activity_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_pre_activity_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ArrayOfAudioDialogReactionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioDialogReaction(self._io, self, self._root)) class EnumStrikeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StrikeType, self.data.value) return getattr(self, '_m_value', None) class SectrGameObjectPathHashHackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumLuaTaskType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LuaTaskType, self.data.value) return getattr(self, '_m_value', None) class AttackCostElementMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_strike_type: self.strike_type = Output.EnumStrikeType(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_attack_type: self.attack_type = Output.EnumAttackType(self._io, self, self._root) if self.has_field_strike_cost_ratio: self.strike_cost_ratio = self._io.read_f4le() if self.has_field_attack_cost_ratio: self.attack_cost_ratio = self._io.read_f4le() if self.has_field_element_cost_ratio: self.element_cost_ratio = self._io.read_f4le() if self.has_field_cost_element_type: self.cost_element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_cost_type: self.cost_type = Output.EnumAttackCostType(self._io, self, self._root) @property def has_field_attack_cost_ratio(self): if hasattr(self, '_m_has_field_attack_cost_ratio'): return self._m_has_field_attack_cost_ratio self._m_has_field_attack_cost_ratio = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_attack_cost_ratio', None) @property def has_field_attack_type(self): if hasattr(self, '_m_has_field_attack_type'): return self._m_has_field_attack_type self._m_has_field_attack_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attack_type', None) @property def has_field_element_cost_ratio(self): if hasattr(self, '_m_has_field_element_cost_ratio'): return self._m_has_field_element_cost_ratio self._m_has_field_element_cost_ratio = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_element_cost_ratio', None) @property def has_field_strike_type(self): if hasattr(self, '_m_has_field_strike_type'): return self._m_has_field_strike_type self._m_has_field_strike_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_strike_type', None) @property def has_field_cost_type(self): if hasattr(self, '_m_has_field_cost_type'): return self._m_has_field_cost_type self._m_has_field_cost_type = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_cost_type', None) @property def has_field_cost_element_type(self): if hasattr(self, '_m_has_field_cost_element_type'): return self._m_has_field_cost_element_type self._m_has_field_cost_element_type = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_cost_element_type', None) @property def has_field_strike_cost_ratio(self): if hasattr(self, '_m_has_field_strike_cost_ratio'): return self._m_has_field_strike_cost_ratio self._m_has_field_strike_cost_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_strike_cost_ratio', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_type', None) class ConfigAirflowField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigConstForceField(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scale: self.scale = self._io.read_f4le() if self.has_field_stay_effect: self.stay_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_enter_effect: self.enter_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_auto_fly: self.auto_fly = self._io.read_u1() if self.has_field_force_hor: self.force_hor = self._io.read_u1() @property def has_field_enter_effect(self): if hasattr(self, '_m_has_field_enter_effect'): return self._m_has_field_enter_effect self._m_has_field_enter_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enter_effect', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_auto_fly(self): if hasattr(self, '_m_has_field_auto_fly'): return self._m_has_field_auto_fly self._m_has_field_auto_fly = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_auto_fly', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_force_hor(self): if hasattr(self, '_m_has_field_force_hor'): return self._m_has_field_force_hor self._m_has_field_force_hor = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_force_hor', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_stay_effect(self): if hasattr(self, '_m_has_field_stay_effect'): return self._m_has_field_stay_effect self._m_has_field_stay_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stay_effect', None) class EnumControlPartTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ControlPartTargetType, self.data.value) return getattr(self, '_m_value', None) class ConfigEntityReuse(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_destroy_time: self.destroy_time = self._io.read_f4le() if self.has_field_max_entity_count: self.max_entity_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_destroy_time(self): if hasattr(self, '_m_has_field_destroy_time'): return self._m_has_field_destroy_time self._m_has_field_destroy_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_destroy_time', None) @property def has_field_max_entity_count(self): if hasattr(self, '_m_has_field_max_entity_count'): return self._m_has_field_max_entity_count self._m_has_field_max_entity_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_entity_count', None) class WeaponMaterialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuideLongPressType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideLongPressType, self.data.value) return getattr(self, '_m_value', None) class EnumActionEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionEventType, self.data.value) return getattr(self, '_m_value', None) class RegionSearchCondExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest: self.main_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest: self.pre_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mini_quest: self.mini_quest = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_pre_quest(self): if hasattr(self, '_m_has_field_pre_quest'): return self._m_has_field_pre_quest self._m_has_field_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_pre_quest', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_mini_quest(self): if hasattr(self, '_m_has_field_mini_quest'): return self._m_has_field_mini_quest self._m_has_field_mini_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mini_quest', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_main_quest(self): if hasattr(self, '_m_has_field_main_quest'): return self._m_has_field_main_quest self._m_has_field_main_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_main_quest', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) class ArrayOfEnumWidgetSkillReplaceTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumWidgetSkillReplaceType(self._io, self, self._root)) class ConfigJudgeAvatarFaceCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_face_degree: self.face_degree = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_face_degree(self): if hasattr(self, '_m_has_field_face_degree'): return self._m_has_field_face_degree self._m_has_field_face_degree = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_face_degree', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class RogueDiaryStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_normal_dungeon_id_list: self.normal_dungeon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hard_dungeon_id_list: self.hard_dungeon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_insane_dungeon_id_list: self.insane_dungeon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_optional_card_count: self.optional_card_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chosen_card_count: self.chosen_card_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tired_type: self.tired_type = Output.EnumRogueDiaryTiredType(self._io, self, self._root) if self.has_field_tired_reserve_avatar_count: self.tired_reserve_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tired_round_count: self.tired_round_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_time_level_list: self.time_level_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_name: self.dungeon_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_desc: self.dungeon_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_hard_dungeon_id_list(self): if hasattr(self, '_m_has_field_hard_dungeon_id_list'): return self._m_has_field_hard_dungeon_id_list self._m_has_field_hard_dungeon_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hard_dungeon_id_list', None) @property def has_field_tired_round_count(self): if hasattr(self, '_m_has_field_tired_round_count'): return self._m_has_field_tired_round_count self._m_has_field_tired_round_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_tired_round_count', None) @property def has_field_normal_dungeon_id_list(self): if hasattr(self, '_m_has_field_normal_dungeon_id_list'): return self._m_has_field_normal_dungeon_id_list self._m_has_field_normal_dungeon_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_normal_dungeon_id_list', None) @property def has_field_chosen_card_count(self): if hasattr(self, '_m_has_field_chosen_card_count'): return self._m_has_field_chosen_card_count self._m_has_field_chosen_card_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_chosen_card_count', None) @property def has_field_tired_type(self): if hasattr(self, '_m_has_field_tired_type'): return self._m_has_field_tired_type self._m_has_field_tired_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_tired_type', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_optional_card_count(self): if hasattr(self, '_m_has_field_optional_card_count'): return self._m_has_field_optional_card_count self._m_has_field_optional_card_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_optional_card_count', None) @property def has_field_tired_reserve_avatar_count(self): if hasattr(self, '_m_has_field_tired_reserve_avatar_count'): return self._m_has_field_tired_reserve_avatar_count self._m_has_field_tired_reserve_avatar_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_tired_reserve_avatar_count', None) @property def has_field_time_level_list(self): if hasattr(self, '_m_has_field_time_level_list'): return self._m_has_field_time_level_list self._m_has_field_time_level_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_time_level_list', None) @property def has_field_dungeon_desc(self): if hasattr(self, '_m_has_field_dungeon_desc'): return self._m_has_field_dungeon_desc self._m_has_field_dungeon_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_dungeon_desc', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_insane_dungeon_id_list(self): if hasattr(self, '_m_has_field_insane_dungeon_id_list'): return self._m_has_field_insane_dungeon_id_list self._m_has_field_insane_dungeon_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_insane_dungeon_id_list', None) @property def has_field_dungeon_name(self): if hasattr(self, '_m_has_field_dungeon_name'): return self._m_has_field_dungeon_name self._m_has_field_dungeon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_name', None) class ArrayOfExpeditionOpenConditionLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ExpeditionOpenCondition(self._io, self, self._root)) class IdCountConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_count', None) class DynamicInteractionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigHomeworldSuiteNpcSpawnPointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldSuiteNpcSpawnPoint(self._io, self, self._root)) class UgcRayTriggerDirectionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityGroupTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldFarmFieldExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_field_item_id: self.field_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_field_type: self.field_type = Output.EnumHomeWorldFieldType(self._io, self, self._root) if self.has_field_field_gadget_id: self.field_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_field_slot_num: self.field_slot_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_field_slot_gadget_id: self.field_slot_gadget_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_field_item_id(self): if hasattr(self, '_m_has_field_field_item_id'): return self._m_has_field_field_item_id self._m_has_field_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_field_item_id', None) @property def has_field_field_gadget_id(self): if hasattr(self, '_m_has_field_field_gadget_id'): return self._m_has_field_field_gadget_id self._m_has_field_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_field_gadget_id', None) @property def has_field_field_slot_gadget_id(self): if hasattr(self, '_m_has_field_field_slot_gadget_id'): return self._m_has_field_field_slot_gadget_id self._m_has_field_field_slot_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_field_slot_gadget_id', None) @property def has_field_field_slot_num(self): if hasattr(self, '_m_has_field_field_slot_num'): return self._m_has_field_field_slot_num self._m_has_field_field_slot_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_field_slot_num', None) @property def has_field_field_type(self): if hasattr(self, '_m_has_field_field_type'): return self._m_has_field_field_type self._m_has_field_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_field_type', None) class EnumDungeonRosterCycleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonRosterCycleType, self.data.value) return getattr(self, '_m_value', None) class BoolIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MechanicusSequenceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioStateGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_state_group_key: self.state_group_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_state_value: self.state_value = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_state_group_key(self): if hasattr(self, '_m_has_field_state_group_key'): return self._m_has_field_state_group_key self._m_has_field_state_group_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_group_key', None) @property def has_field_state_value(self): if hasattr(self, '_m_has_field_state_value'): return self._m_has_field_state_value self._m_has_field_state_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_value', None) class ByTargetGadgetState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_state: self.gadget_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_gadget_state(self): if hasattr(self, '_m_has_field_gadget_state'): return self._m_has_field_gadget_state self._m_has_field_gadget_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_state', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigCrystal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_gain_speed: self.gain_speed = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drain_speed: self.drain_speed = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resonate_levels: self.resonate_levels = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_burst_resonate: self.burst_resonate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_burst_skill: self.burst_skill = AuxTypes.String(self._io, self, self._root) if self.has_field_burst_time: self.burst_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_respawn_time: self.respawn_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_drain_speed(self): if hasattr(self, '_m_has_field_drain_speed'): return self._m_has_field_drain_speed self._m_has_field_drain_speed = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_drain_speed', None) @property def has_field_respawn_time(self): if hasattr(self, '_m_has_field_respawn_time'): return self._m_has_field_respawn_time self._m_has_field_respawn_time = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_respawn_time', None) @property def has_field_burst_skill(self): if hasattr(self, '_m_has_field_burst_skill'): return self._m_has_field_burst_skill self._m_has_field_burst_skill = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_burst_skill', None) @property def has_field_gain_speed(self): if hasattr(self, '_m_has_field_gain_speed'): return self._m_has_field_gain_speed self._m_has_field_gain_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gain_speed', None) @property def has_field_burst_time(self): if hasattr(self, '_m_has_field_burst_time'): return self._m_has_field_burst_time self._m_has_field_burst_time = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_burst_time', None) @property def has_field_burst_resonate(self): if hasattr(self, '_m_has_field_burst_resonate'): return self._m_has_field_burst_resonate self._m_has_field_burst_resonate = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_burst_resonate', None) @property def has_field_resonate_levels(self): if hasattr(self, '_m_has_field_resonate_levels'): return self._m_has_field_resonate_levels self._m_has_field_resonate_levels = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_resonate_levels', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) class SceneTagCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductCardDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomRewardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMotionBlurQuality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MotionBlurQuality, self.data.value) return getattr(self, '_m_value', None) class ElementAttachForActivityGacha(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element: self.element = Output.EnumElementType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_element(self): if hasattr(self, '_m_has_field_element'): return self._m_has_field_element self._m_has_field_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class AvatarReplaceCostumeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_replace_costume_id: self.replace_costume_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_replace_costume_id(self): if hasattr(self, '_m_has_field_replace_costume_id'): return self._m_has_field_replace_costume_id self._m_has_field_replace_costume_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_replace_costume_id', None) class EnumConfigWeatherType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigWeatherType, self.data.value) return getattr(self, '_m_value', None) class FleurFairBuffEnergyStatExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigActionButtonLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigActionButton(self._io, self, self._root)) class ActivityGearExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_level_id_list: self.gear_level_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gear_tooth_length: self.gear_tooth_length = self._io.read_f4le() if self.has_field_gear_thickness: self.gear_thickness = self._io.read_f4le() if self.has_field_shaft_select_effect: self.shaft_select_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_shaft_tip_effect: self.shaft_tip_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_end_gear_success_effect: self.end_gear_success_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_cover_up_effect: self.cover_up_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_gear_place_effect: self.gear_place_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_player_tip_delay: self.player_tip_delay = self._io.read_f4le() @property def has_field_gear_thickness(self): if hasattr(self, '_m_has_field_gear_thickness'): return self._m_has_field_gear_thickness self._m_has_field_gear_thickness = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gear_thickness', None) @property def has_field_gear_place_effect(self): if hasattr(self, '_m_has_field_gear_place_effect'): return self._m_has_field_gear_place_effect self._m_has_field_gear_place_effect = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_gear_place_effect', None) @property def has_field_gear_level_id_list(self): if hasattr(self, '_m_has_field_gear_level_id_list'): return self._m_has_field_gear_level_id_list self._m_has_field_gear_level_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gear_level_id_list', None) @property def has_field_end_gear_success_effect(self): if hasattr(self, '_m_has_field_end_gear_success_effect'): return self._m_has_field_end_gear_success_effect self._m_has_field_end_gear_success_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_end_gear_success_effect', None) @property def has_field_gear_tooth_length(self): if hasattr(self, '_m_has_field_gear_tooth_length'): return self._m_has_field_gear_tooth_length self._m_has_field_gear_tooth_length = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gear_tooth_length', None) @property def has_field_shaft_select_effect(self): if hasattr(self, '_m_has_field_shaft_select_effect'): return self._m_has_field_shaft_select_effect self._m_has_field_shaft_select_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_shaft_select_effect', None) @property def has_field_player_tip_delay(self): if hasattr(self, '_m_has_field_player_tip_delay'): return self._m_has_field_player_tip_delay self._m_has_field_player_tip_delay = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_player_tip_delay', None) @property def has_field_cover_up_effect(self): if hasattr(self, '_m_has_field_cover_up_effect'): return self._m_has_field_cover_up_effect self._m_has_field_cover_up_effect = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cover_up_effect', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_shaft_tip_effect(self): if hasattr(self, '_m_has_field_shaft_tip_effect'): return self._m_has_field_shaft_tip_effect self._m_has_field_shaft_tip_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_shaft_tip_effect', None) class ActivityGachaRobotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldLimitShopExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_goods_id: self.goods_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfHomeWorldLimitShopCondLengthS(self._io, self, self._root) if self.has_field_buy_limit: self.buy_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pool_id', None) @property def has_field_goods_id(self): if hasattr(self, '_m_has_field_goods_id'): return self._m_has_field_goods_id self._m_has_field_goods_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_goods_id', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_buy_limit(self): if hasattr(self, '_m_has_field_buy_limit'): return self._m_has_field_buy_limit self._m_has_field_buy_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_buy_limit', None) class FindHilichurlExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_quest_id: self.end_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_assignment_id_list: self.assignment_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hili_wei_id_list: self.hili_wei_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_assignment_id_list(self): if hasattr(self, '_m_has_field_assignment_id_list'): return self._m_has_field_assignment_id_list self._m_has_field_assignment_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_assignment_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_end_quest_id(self): if hasattr(self, '_m_has_field_end_quest_id'): return self._m_has_field_end_quest_id self._m_has_field_end_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_end_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_hili_wei_id_list(self): if hasattr(self, '_m_has_field_hili_wei_id_list'): return self._m_has_field_hili_wei_id_list self._m_has_field_hili_wei_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_hili_wei_id_list', None) class EnumChestShowCutsceneType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChestShowCutsceneType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfTowerScheduleLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TowerSchedule(self._io, self, self._root)) class ConfigMusicUInt32listMultiMemberCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_values: self.values = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_values(self): if hasattr(self, '_m_has_field_values'): return self._m_has_field_values self._m_has_field_values = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_values', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ArrayOfDraftTransferConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DraftTransferConfig(self._io, self, self._root)) class ConfigNpcMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAnimatorMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_water_check: self.water_check = self._io.read_u1() @property def velocity_ratio(self): if hasattr(self, '_m_velocity_ratio'): return self._m_velocity_ratio self._m_velocity_ratio = self.base.velocity_ratio return getattr(self, '_m_velocity_ratio', None) @property def has_field_water_check(self): if hasattr(self, '_m_has_field_water_check'): return self._m_has_field_water_check self._m_has_field_water_check = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_water_check', None) @property def init_with_ground_hit_check(self): if hasattr(self, '_m_init_with_ground_hit_check'): return self._m_init_with_ground_hit_check self._m_init_with_ground_hit_check = self.base.init_with_ground_hit_check return getattr(self, '_m_init_with_ground_hit_check', None) @property def land_states(self): if hasattr(self, '_m_land_states'): return self._m_land_states self._m_land_states = self.base.land_states return getattr(self, '_m_land_states', None) @property def smoothed_speed(self): if hasattr(self, '_m_smoothed_speed'): return self._m_smoothed_speed self._m_smoothed_speed = self.base.smoothed_speed return getattr(self, '_m_smoothed_speed', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def position_modify_state(self): if hasattr(self, '_m_position_modify_state'): return self._m_position_modify_state self._m_position_modify_state = self.base.position_modify_state return getattr(self, '_m_position_modify_state', None) @property def position_modify_state_map(self): if hasattr(self, '_m_position_modify_state_map'): return self._m_position_modify_state_map self._m_position_modify_state_map = self.base.position_modify_state_map return getattr(self, '_m_position_modify_state_map', None) @property def monster_size_type(self): if hasattr(self, '_m_monster_size_type'): return self._m_monster_size_type self._m_monster_size_type = self.base.monster_size_type return getattr(self, '_m_monster_size_type', None) @property def move_on_water(self): if hasattr(self, '_m_move_on_water'): return self._m_move_on_water self._m_move_on_water = self.base.move_on_water return getattr(self, '_m_move_on_water', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def position_modify_extra(self): if hasattr(self, '_m_position_modify_extra'): return self._m_position_modify_extra self._m_position_modify_extra = self.base.position_modify_extra return getattr(self, '_m_position_modify_extra', None) @property def move_on_ground(self): if hasattr(self, '_m_move_on_ground'): return self._m_move_on_ground self._m_move_on_ground = self.base.move_on_ground return getattr(self, '_m_move_on_ground', None) @property def raycasts(self): if hasattr(self, '_m_raycasts'): return self._m_raycasts self._m_raycasts = self.base.raycasts return getattr(self, '_m_raycasts', None) @property def yaw_speed_ratio(self): if hasattr(self, '_m_yaw_speed_ratio'): return self._m_yaw_speed_ratio self._m_yaw_speed_ratio = self.base.yaw_speed_ratio return getattr(self, '_m_yaw_speed_ratio', None) @property def launch_states(self): if hasattr(self, '_m_launch_states'): return self._m_launch_states self._m_launch_states = self.base.launch_states return getattr(self, '_m_launch_states', None) @property def facing_move(self): if hasattr(self, '_m_facing_move'): return self._m_facing_move self._m_facing_move = self.base.facing_move return getattr(self, '_m_facing_move', None) @property def destroy_rock_when_init(self): if hasattr(self, '_m_destroy_rock_when_init'): return self._m_destroy_rock_when_init self._m_destroy_rock_when_init = self.base.destroy_rock_when_init return getattr(self, '_m_destroy_rock_when_init', None) @property def air_facing_move(self): if hasattr(self, '_m_air_facing_move'): return self._m_air_facing_move self._m_air_facing_move = self.base.air_facing_move return getattr(self, '_m_air_facing_move', None) @property def move_on_water_depth(self): if hasattr(self, '_m_move_on_water_depth'): return self._m_move_on_water_depth self._m_move_on_water_depth = self.base.move_on_water_depth return getattr(self, '_m_move_on_water_depth', None) class RogueCellTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShapeCircle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) class DispConfigCameraSplineBasePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigCameraSplineBasePoint(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCameraSplineCatmullPoint(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCameraSplineBezierPoint(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivityHideAndSeekBasicConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_one_time_reward_preview_id: self.one_time_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id: self.unlock_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_id: self.match_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_id: self.draft_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_unlock_list: self.score_unlock_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_skill_list: self.skill_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_map_list: self.map_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_chanllenge_list: self.chanllenge_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_score_item_id: self.score_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_unlock_quest_id(self): if hasattr(self, '_m_has_field_unlock_quest_id'): return self._m_has_field_unlock_quest_id self._m_has_field_unlock_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_quest_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_one_time_reward_preview_id(self): if hasattr(self, '_m_has_field_one_time_reward_preview_id'): return self._m_has_field_one_time_reward_preview_id self._m_has_field_one_time_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_one_time_reward_preview_id', None) @property def has_field_match_id(self): if hasattr(self, '_m_has_field_match_id'): return self._m_has_field_match_id self._m_has_field_match_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_match_id', None) @property def has_field_score_unlock_list(self): if hasattr(self, '_m_has_field_score_unlock_list'): return self._m_has_field_score_unlock_list self._m_has_field_score_unlock_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_score_unlock_list', None) @property def has_field_map_list(self): if hasattr(self, '_m_has_field_map_list'): return self._m_has_field_map_list self._m_has_field_map_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_map_list', None) @property def has_field_score_item_id(self): if hasattr(self, '_m_has_field_score_item_id'): return self._m_has_field_score_item_id self._m_has_field_score_item_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_score_item_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_draft_id(self): if hasattr(self, '_m_has_field_draft_id'): return self._m_has_field_draft_id self._m_has_field_draft_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_draft_id', None) @property def has_field_chanllenge_list(self): if hasattr(self, '_m_has_field_chanllenge_list'): return self._m_has_field_chanllenge_list self._m_has_field_chanllenge_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_chanllenge_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_skill_list(self): if hasattr(self, '_m_has_field_skill_list'): return self._m_has_field_skill_list self._m_has_field_skill_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_skill_list', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class EnumAsterPhase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AsterPhase, self.data.value) return getattr(self, '_m_value', None) class EnumCustomGadgetRootType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CustomGadgetRootType, self.data.value) return getattr(self, '_m_value', None) class SalvagePlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetToyLunchBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_revive_materials: self.revive_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_heal_materials: self.heal_materials = Output.ConfigWidgetToyLunchBoxHealMaterial(self._io, self, self._root) @property def has_field_revive_materials(self): if hasattr(self, '_m_has_field_revive_materials'): return self._m_has_field_revive_materials self._m_has_field_revive_materials = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_revive_materials', None) @property def has_field_heal_materials(self): if hasattr(self, '_m_has_field_heal_materials'): return self._m_has_field_heal_materials self._m_has_field_heal_materials = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_heal_materials', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class GadgetChargeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_charge_type: self.charge_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_charge_ratio: self.charge_ratio = self._io.read_f4le() if self.has_field_charge_value: self.charge_value = self._io.read_f4le() if self.has_field_max_charge_value: self.max_charge_value = self._io.read_f4le() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_ratio_global_value_key: self.ratio_global_value_key = AuxTypes.String(self._io, self, self._root) @property def has_field_charge_ratio(self): if hasattr(self, '_m_has_field_charge_ratio'): return self._m_has_field_charge_ratio self._m_has_field_charge_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_charge_ratio', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_charge_type(self): if hasattr(self, '_m_has_field_charge_type'): return self._m_has_field_charge_type self._m_has_field_charge_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_charge_type', None) @property def has_field_charge_value(self): if hasattr(self, '_m_has_field_charge_value'): return self._m_has_field_charge_value self._m_has_field_charge_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_charge_value', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_max_charge_value(self): if hasattr(self, '_m_has_field_max_charge_value'): return self._m_has_field_max_charge_value self._m_has_field_max_charge_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_charge_value', None) @property def has_field_ratio_global_value_key(self): if hasattr(self, '_m_has_field_ratio_global_value_key'): return self._m_has_field_ratio_global_value_key self._m_has_field_ratio_global_value_key = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_ratio_global_value_key', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class ConfigAudioNpc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_vocal_bone_name: self.default_vocal_bone_name = AuxTypes.String(self._io, self, self._root) @property def has_field_default_vocal_bone_name(self): if hasattr(self, '_m_has_field_default_vocal_bone_name'): return self._m_has_field_default_vocal_bone_name self._m_has_field_default_vocal_bone_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_vocal_bone_name', None) class PsActivitiesTaskConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_name: self.task_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_required_for_completion: self.is_required_for_completion = self._io.read_u1() if self.has_field_hidden: self.hidden = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_object_id: self.object_id = AuxTypes.String(self._io, self, self._root) if self.has_field_export_version: self.export_version = AuxTypes.String(self._io, self, self._root) @property def has_field_is_required_for_completion(self): if hasattr(self, '_m_has_field_is_required_for_completion'): return self._m_has_field_is_required_for_completion self._m_has_field_is_required_for_completion = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_required_for_completion', None) @property def has_field_export_version(self): if hasattr(self, '_m_has_field_export_version'): return self._m_has_field_export_version self._m_has_field_export_version = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_export_version', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_object_id(self): if hasattr(self, '_m_has_field_object_id'): return self._m_has_field_object_id self._m_has_field_object_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_object_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_hidden(self): if hasattr(self, '_m_has_field_hidden'): return self._m_has_field_hidden self._m_has_field_hidden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hidden', None) @property def has_field_task_name(self): if hasattr(self, '_m_has_field_task_name'): return self._m_has_field_task_name self._m_has_field_task_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_task_name', None) class DictOfEnumActionPanelStateAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumActionPanelStateAuxTypesString(self._io, self, self._root)) class KvpOfDictEnumMarkIconTypeConfigMarkIcon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumMarkIconType(self._io, self, self._root) self.value = Output.ConfigMarkIcon(self._io, self, self._root) class ConfigGadgetStateSendEffectTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAnimatorParamType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_parameter', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_effect_pattern', None) class IrodoriChessCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoguelikeShikigamiExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideVirtualDialActionCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_virtual_dial_action: self.virtual_dial_action = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_virtual_dial_action(self): if hasattr(self, '_m_has_field_virtual_dial_action'): return self._m_has_field_virtual_dial_action self._m_has_field_virtual_dial_action = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_virtual_dial_action', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class FishBaitExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MultiPositionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EffectChangeAlphaMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_start_duration: self.start_duration = self._io.read_f4le() if self.has_field_end_duration: self.end_duration = self._io.read_f4le() @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_start_duration(self): if hasattr(self, '_m_has_field_start_duration'): return self._m_has_field_start_duration self._m_has_field_start_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_start_duration', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_end_duration(self): if hasattr(self, '_m_has_field_end_duration'): return self._m_has_field_end_duration self._m_has_field_end_duration = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_end_duration', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialChaseData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSpacialChaseData(self._io, self, self._root) class CutsceneExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBaseEquipController(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sheath_point: self.sheath_point = AuxTypes.String(self._io, self, self._root) if self.has_field_dissolve_sheath_fade_delay: self.dissolve_sheath_fade_delay = self._io.read_f4le() if self.has_field_dissolve_sheath_fade_time: self.dissolve_sheath_fade_time = self._io.read_f4le() if self.has_field_dissolve_take_fade_time: self.dissolve_take_fade_time = self._io.read_f4le() if self.has_field_trigger_to_states: self.trigger_to_states = Output.ArrayOfTriggerToStatesLengthU(self._io, self, self._root) @property def has_field_dissolve_sheath_fade_delay(self): if hasattr(self, '_m_has_field_dissolve_sheath_fade_delay'): return self._m_has_field_dissolve_sheath_fade_delay self._m_has_field_dissolve_sheath_fade_delay = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dissolve_sheath_fade_delay', None) @property def has_field_sheath_point(self): if hasattr(self, '_m_has_field_sheath_point'): return self._m_has_field_sheath_point self._m_has_field_sheath_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sheath_point', None) @property def has_field_dissolve_sheath_fade_time(self): if hasattr(self, '_m_has_field_dissolve_sheath_fade_time'): return self._m_has_field_dissolve_sheath_fade_time self._m_has_field_dissolve_sheath_fade_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dissolve_sheath_fade_time', None) @property def has_field_trigger_to_states(self): if hasattr(self, '_m_has_field_trigger_to_states'): return self._m_has_field_trigger_to_states self._m_has_field_trigger_to_states = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_trigger_to_states', None) @property def has_field_dissolve_take_fade_time(self): if hasattr(self, '_m_has_field_dissolve_take_fade_time'): return self._m_has_field_dissolve_take_fade_time self._m_has_field_dissolve_take_fade_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_dissolve_take_fade_time', None) class ConfigEntityAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_anim_audio: self.anim_audio = Output.ConfigAnimationAudio(self._io, self, self._root) if self.has_field_init_event: self.init_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enable_event: self.enable_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_disable_event: self.disable_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_destroy_event: self.destroy_event = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_enable_event(self): if hasattr(self, '_m_has_field_enable_event'): return self._m_has_field_enable_event self._m_has_field_enable_event = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enable_event', None) @property def has_field_destroy_event(self): if hasattr(self, '_m_has_field_destroy_event'): return self._m_has_field_destroy_event self._m_has_field_destroy_event = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_destroy_event', None) @property def has_field_anim_audio(self): if hasattr(self, '_m_has_field_anim_audio'): return self._m_has_field_anim_audio self._m_has_field_anim_audio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_anim_audio', None) @property def has_field_init_event(self): if hasattr(self, '_m_has_field_init_event'): return self._m_has_field_init_event self._m_has_field_init_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_init_event', None) @property def has_field_disable_event(self): if hasattr(self, '_m_has_field_disable_event'): return self._m_has_field_disable_event self._m_has_field_disable_event = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_disable_event', None) class LuaCallTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfTalkCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TalkCond(self._io, self, self._root)) class QuestGlobalVarConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_default_value: self.default_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_default_value(self): if hasattr(self, '_m_has_field_default_value'): return self._m_has_field_default_value self._m_has_field_default_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_default_value', None) class MoveStateMixinTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SummerTimeV2boatConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeworldModuleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_free: self.is_free = self._io.read_u1() if self.has_field_unlock_tip_if_un_free: self.unlock_tip_if_un_free = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_world_scene_id: self.world_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_default_room_scene_id: self.default_room_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_optional_room_scene_id_vec: self.optional_room_scene_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_module_name: self.module_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_module_desc: self.module_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region: self.region = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_region_point_pos: self.region_point_pos = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_small_image_addr: self.small_image_addr = AuxTypes.String(self._io, self, self._root) if self.has_field_big_image_addr: self.big_image_addr = AuxTypes.String(self._io, self, self._root) @property def has_field_world_scene_id(self): if hasattr(self, '_m_has_field_world_scene_id'): return self._m_has_field_world_scene_id self._m_has_field_world_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_world_scene_id', None) @property def has_field_module_name(self): if hasattr(self, '_m_has_field_module_name'): return self._m_has_field_module_name self._m_has_field_module_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_module_name', None) @property def has_field_module_desc(self): if hasattr(self, '_m_has_field_module_desc'): return self._m_has_field_module_desc self._m_has_field_module_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_module_desc', None) @property def has_field_default_room_scene_id(self): if hasattr(self, '_m_has_field_default_room_scene_id'): return self._m_has_field_default_room_scene_id self._m_has_field_default_room_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_default_room_scene_id', None) @property def has_field_unlock_tip_if_un_free(self): if hasattr(self, '_m_has_field_unlock_tip_if_un_free'): return self._m_has_field_unlock_tip_if_un_free self._m_has_field_unlock_tip_if_un_free = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_tip_if_un_free', None) @property def has_field_small_image_addr(self): if hasattr(self, '_m_has_field_small_image_addr'): return self._m_has_field_small_image_addr self._m_has_field_small_image_addr = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_small_image_addr', None) @property def has_field_is_free(self): if hasattr(self, '_m_has_field_is_free'): return self._m_has_field_is_free self._m_has_field_is_free = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_free', None) @property def has_field_big_image_addr(self): if hasattr(self, '_m_has_field_big_image_addr'): return self._m_has_field_big_image_addr self._m_has_field_big_image_addr = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_big_image_addr', None) @property def has_field_region_point_pos(self): if hasattr(self, '_m_has_field_region_point_pos'): return self._m_has_field_region_point_pos self._m_has_field_region_point_pos = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_region_point_pos', None) @property def has_field_region(self): if hasattr(self, '_m_has_field_region'): return self._m_has_field_region self._m_has_field_region = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_region', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_optional_room_scene_id_vec(self): if hasattr(self, '_m_has_field_optional_room_scene_id_vec'): return self._m_has_field_optional_room_scene_id_vec self._m_has_field_optional_room_scene_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_optional_room_scene_id_vec', None) class TriggerBeHitSupportMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TriggerTypeSupportMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_level: self.hit_level = Output.EnumHitLevel(self._io, self, self._root) @property def has_field_hit_level(self): if hasattr(self, '_m_has_field_hit_level'): return self._m_has_field_hit_level self._m_has_field_hit_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_level', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def radius(self): if hasattr(self, '_m_radius'): return self._m_radius self._m_radius = self.base.radius return getattr(self, '_m_radius', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class LanV2projectionElementConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_shadow_prefab_path: self.shadow_prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_switch_button_config_id: self.switch_button_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_correct_pose: self.correct_pose = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_initial_pose: self.initial_pose = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_motion_type: self.motion_type = Output.EnumLanV2projectionMotionType(self._io, self, self._root) if self.has_field_free_rotation_tolerance: self.free_rotation_tolerance = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_single_axis_motion_axis: self.single_axis_motion_axis = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_single_axis_motion_limit: self.single_axis_motion_limit = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_single_axis_motion_tolerance: self.single_axis_motion_tolerance = self._io.read_f4le() @property def has_field_shadow_prefab_path(self): if hasattr(self, '_m_has_field_shadow_prefab_path'): return self._m_has_field_shadow_prefab_path self._m_has_field_shadow_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_shadow_prefab_path', None) @property def has_field_single_axis_motion_tolerance(self): if hasattr(self, '_m_has_field_single_axis_motion_tolerance'): return self._m_has_field_single_axis_motion_tolerance self._m_has_field_single_axis_motion_tolerance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_single_axis_motion_tolerance', None) @property def has_field_single_axis_motion_limit(self): if hasattr(self, '_m_has_field_single_axis_motion_limit'): return self._m_has_field_single_axis_motion_limit self._m_has_field_single_axis_motion_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_single_axis_motion_limit', None) @property def has_field_single_axis_motion_axis(self): if hasattr(self, '_m_has_field_single_axis_motion_axis'): return self._m_has_field_single_axis_motion_axis self._m_has_field_single_axis_motion_axis = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_single_axis_motion_axis', None) @property def has_field_initial_pose(self): if hasattr(self, '_m_has_field_initial_pose'): return self._m_has_field_initial_pose self._m_has_field_initial_pose = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_initial_pose', None) @property def has_field_switch_button_config_id(self): if hasattr(self, '_m_has_field_switch_button_config_id'): return self._m_has_field_switch_button_config_id self._m_has_field_switch_button_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_switch_button_config_id', None) @property def has_field_correct_pose(self): if hasattr(self, '_m_has_field_correct_pose'): return self._m_has_field_correct_pose self._m_has_field_correct_pose = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_correct_pose', None) @property def has_field_motion_type(self): if hasattr(self, '_m_has_field_motion_type'): return self._m_has_field_motion_type self._m_has_field_motion_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_motion_type', None) @property def has_field_free_rotation_tolerance(self): if hasattr(self, '_m_has_field_free_rotation_tolerance'): return self._m_has_field_free_rotation_tolerance self._m_has_field_free_rotation_tolerance = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_free_rotation_tolerance', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prefab_path', None) class SetCameraLockTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lock_time: self.lock_time = self._io.read_f4le() @property def has_field_lock_time(self): if hasattr(self, '_m_has_field_lock_time'): return self._m_has_field_lock_time self._m_has_field_lock_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lock_time', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SteerAttackTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TreasureMapBonusRegionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioEventCulling(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_rule_map: self.rule_map = Output.DictOfAuxTypesStringArrayOfDispConfigAudioEventCullingRuleBaseLengthU(self._io, self, self._root) if self.has_field_global_rules: self.global_rules = Output.ArrayOfDispConfigAudioEventCullingRuleBaseLengthU(self._io, self, self._root) @property def has_field_rule_map(self): if hasattr(self, '_m_has_field_rule_map'): return self._m_has_field_rule_map self._m_has_field_rule_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_rule_map', None) @property def has_field_global_rules(self): if hasattr(self, '_m_has_field_global_rules'): return self._m_has_field_global_rules self._m_has_field_global_rules = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_global_rules', None) class IrodoriChessAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) class EnumMechanicusCardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MechanicusCardType, self.data.value) return getattr(self, '_m_value', None) class ProgressShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfStringKeyItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_device_spec_item: self.device_spec_item = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfStringKeyItemOptionArrayInfo(self._io, self, self._root) if self.has_field_override_map: self.override_map = Output.DictOfAuxTypesStringConfigPerfStringKeyItemOverrideInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def has_field_override_map(self): if hasattr(self, '_m_has_field_override_map'): return self._m_has_field_override_map self._m_has_field_override_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map', None) @property def has_field_device_spec_item(self): if hasattr(self, '_m_has_field_device_spec_item'): return self._m_has_field_device_spec_item self._m_has_field_device_spec_item = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_device_spec_item', None) class ByTargetIsSelf(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_self: self.is_self = self._io.read_u1() @property def has_field_is_self(self): if hasattr(self, '_m_has_field_is_self'): return self._m_has_field_is_self self._m_has_field_is_self = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_self', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfEnumModifierTagLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumModifierTag(self._io, self, self._root)) class FindHilichurlExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiReactActionPointData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiReactActionPointData(self._io, self, self._root) class ConfigPlatformGrahpicsSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_volatile_settings: self.volatile_settings = Output.DictOfEnumVolatileTypeConfigGraphicsVolatileSetting(self._io, self, self._root) if self.has_field_device_settings: self.device_settings = Output.DictOfAuxTypesStringConfigGraphicsRecommendSetting(self._io, self, self._root) if self.has_field_target_frame_rate: self.target_frame_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_antialiasing_method: self.antialiasing_method = Output.EnumAntialiasingMethod(self._io, self, self._root) if self.has_field_taa_quality: self.taa_quality = Output.EnumTaaQuality(self._io, self, self._root) if self.has_field_smaa_quality: self.smaa_quality = Output.EnumSmaaQuality(self._io, self, self._root) if self.has_field_candidate_volatile: self.candidate_volatile = Output.ArrayOfEnumVolatileTypeLengthU(self._io, self, self._root) if self.has_field_postprocess_effect_options: self.postprocess_effect_options = Output.DictOfEnumOptionTypeConfigPostprocessEffectSetting(self._io, self, self._root) if self.has_field_particle_effect_options: self.particle_effect_options = Output.DictOfEnumOptionTypeConfigParticleEffectSetting(self._io, self, self._root) if self.has_field_comprehensive_quality_options: self.comprehensive_quality_options = Output.DictOfEnumOptionTypeConfigComprehensiveQualitySetting(self._io, self, self._root) if self.has_field_setting_entry: self.setting_entry = Output.ArrayOfConfigGraphicsSettingEntryLengthU(self._io, self, self._root) if self.has_field_performance_settings: self.performance_settings = Output.DictOfAuxTypesStringConfigPerformanceSetting(self._io, self, self._root) if self.has_field_global_token_settings: self.global_token_settings = Output.ConfigGlobalToken(self._io, self, self._root) if self.has_field_shadow_quality_settings: self.shadow_quality_settings = Output.DictOfEnumShadowQualityConfigShadowQualitySetting(self._io, self, self._root) if self.has_field_cost_ratio_grade: self.cost_ratio_grade = Output.DictOfEnumPerfCostRatioGradeF4(self._io, self, self._root) if self.has_field_level_streaming_cost_map: self.level_streaming_cost_map = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeS(self._io, self, self._root) if self.has_field_fade_distance_quality_settings: self.fade_distance_quality_settings = Output.DictOfEnumFadeTintQualityLevelConfigTintFadeSetting(self._io, self, self._root) if self.has_field_device_model_use_width_match_mode: self.device_model_use_width_match_mode = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_candidate_volatile(self): if hasattr(self, '_m_has_field_candidate_volatile'): return self._m_has_field_candidate_volatile self._m_has_field_candidate_volatile = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_candidate_volatile', None) @property def has_field_taa_quality(self): if hasattr(self, '_m_has_field_taa_quality'): return self._m_has_field_taa_quality self._m_has_field_taa_quality = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_taa_quality', None) @property def has_field_comprehensive_quality_options(self): if hasattr(self, '_m_has_field_comprehensive_quality_options'): return self._m_has_field_comprehensive_quality_options self._m_has_field_comprehensive_quality_options = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_comprehensive_quality_options', None) @property def has_field_level_streaming_cost_map(self): if hasattr(self, '_m_has_field_level_streaming_cost_map'): return self._m_has_field_level_streaming_cost_map self._m_has_field_level_streaming_cost_map = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_level_streaming_cost_map', None) @property def has_field_target_frame_rate(self): if hasattr(self, '_m_has_field_target_frame_rate'): return self._m_has_field_target_frame_rate self._m_has_field_target_frame_rate = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_target_frame_rate', None) @property def has_field_smaa_quality(self): if hasattr(self, '_m_has_field_smaa_quality'): return self._m_has_field_smaa_quality self._m_has_field_smaa_quality = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_smaa_quality', None) @property def has_field_postprocess_effect_options(self): if hasattr(self, '_m_has_field_postprocess_effect_options'): return self._m_has_field_postprocess_effect_options self._m_has_field_postprocess_effect_options = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_postprocess_effect_options', None) @property def has_field_fade_distance_quality_settings(self): if hasattr(self, '_m_has_field_fade_distance_quality_settings'): return self._m_has_field_fade_distance_quality_settings self._m_has_field_fade_distance_quality_settings = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_fade_distance_quality_settings', None) @property def has_field_cost_ratio_grade(self): if hasattr(self, '_m_has_field_cost_ratio_grade'): return self._m_has_field_cost_ratio_grade self._m_has_field_cost_ratio_grade = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_cost_ratio_grade', None) @property def has_field_global_token_settings(self): if hasattr(self, '_m_has_field_global_token_settings'): return self._m_has_field_global_token_settings self._m_has_field_global_token_settings = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_global_token_settings', None) @property def has_field_volatile_settings(self): if hasattr(self, '_m_has_field_volatile_settings'): return self._m_has_field_volatile_settings self._m_has_field_volatile_settings = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_volatile_settings', None) @property def has_field_antialiasing_method(self): if hasattr(self, '_m_has_field_antialiasing_method'): return self._m_has_field_antialiasing_method self._m_has_field_antialiasing_method = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_antialiasing_method', None) @property def has_field_particle_effect_options(self): if hasattr(self, '_m_has_field_particle_effect_options'): return self._m_has_field_particle_effect_options self._m_has_field_particle_effect_options = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_particle_effect_options', None) @property def has_field_setting_entry(self): if hasattr(self, '_m_has_field_setting_entry'): return self._m_has_field_setting_entry self._m_has_field_setting_entry = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_setting_entry', None) @property def has_field_shadow_quality_settings(self): if hasattr(self, '_m_has_field_shadow_quality_settings'): return self._m_has_field_shadow_quality_settings self._m_has_field_shadow_quality_settings = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_shadow_quality_settings', None) @property def has_field_device_settings(self): if hasattr(self, '_m_has_field_device_settings'): return self._m_has_field_device_settings self._m_has_field_device_settings = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_device_settings', None) @property def has_field_device_model_use_width_match_mode(self): if hasattr(self, '_m_has_field_device_model_use_width_match_mode'): return self._m_has_field_device_model_use_width_match_mode self._m_has_field_device_model_use_width_match_mode = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_device_model_use_width_match_mode', None) @property def has_field_performance_settings(self): if hasattr(self, '_m_has_field_performance_settings'): return self._m_has_field_performance_settings self._m_has_field_performance_settings = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_performance_settings', None) class ByEquipAffixReady(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_equip_affix_data_id: self.equip_affix_data_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_equip_affix_data_id(self): if hasattr(self, '_m_has_field_equip_affix_data_id'): return self._m_has_field_equip_affix_data_id self._m_has_field_equip_affix_data_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip_affix_data_id', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigJudgeNodeContainerWithGroupEntityInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeContainer(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group_entity: self.group_entity = Output.ConfigJudgeGroupEntity(self._io, self, self._root) @property def has_field_group_entity(self): if hasattr(self, '_m_has_field_group_entity'): return self._m_has_field_group_entity self._m_has_field_group_entity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_entity', None) @property def sub_nodes(self): if hasattr(self, '_m_sub_nodes'): return self._m_sub_nodes self._m_sub_nodes = self.base.sub_nodes return getattr(self, '_m_sub_nodes', None) @property def sub_node_logic_comb(self): if hasattr(self, '_m_sub_node_logic_comb'): return self._m_sub_node_logic_comb self._m_sub_node_logic_comb = self.base.sub_node_logic_comb return getattr(self, '_m_sub_node_logic_comb', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class EnumSystemValuerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SystemValuerType, self.data.value) return getattr(self, '_m_value', None) class ContextActionSetActive(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_element: self.ui_element = Output.EnumActivityBannerUiElementType(self._io, self, self._root) if self.has_field_active: self.active = self._io.read_u1() if self.has_field_set_parent: self.set_parent = self._io.read_u1() @property def has_field_ui_element(self): if hasattr(self, '_m_has_field_ui_element'): return self._m_has_field_ui_element self._m_has_field_ui_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_element', None) @property def has_field_active(self): if hasattr(self, '_m_has_field_active'): return self._m_has_field_active self._m_has_field_active = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_active', None) @property def has_field_set_parent(self): if hasattr(self, '_m_has_field_set_parent'): return self._m_has_field_set_parent self._m_has_field_set_parent = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_parent', None) class PlaceNameConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAvatarPerform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_standby: self.standby = Output.ConfigStandbyPerform(self._io, self, self._root) @property def has_field_standby(self): if hasattr(self, '_m_has_field_standby'): return self._m_has_field_standby self._m_has_field_standby = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_standby', None) class ArrayOfArrayOfAudioRequirementLengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfAudioRequirementLengthU(self._io, self, self._root)) class ByHasFeatureTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_feature_tag_i_ds: self.feature_tag_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_feature_tag_i_ds(self): if hasattr(self, '_m_has_field_feature_tag_i_ds'): return self._m_has_field_feature_tag_i_ds self._m_has_field_feature_tag_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_feature_tag_i_ds', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ByTargetGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_force_by_caster: self.force_by_caster = self._io.read_u1() if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_force_by_caster(self): if hasattr(self, '_m_has_field_force_by_caster'): return self._m_has_field_force_by_caster self._m_has_field_force_by_caster = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_force_by_caster', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_compare_type', None) class ReunionSignInExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) class ConfigGuideContextList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_main_page_black: self.main_page_black = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_dialog_black: self.dialog_black = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_global_white: self.global_white = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_interval_black: self.interval_black = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_prefab_and_hint_white: self.prefab_and_hint_white = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_interval_black(self): if hasattr(self, '_m_has_field_interval_black'): return self._m_has_field_interval_black self._m_has_field_interval_black = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_interval_black', None) @property def has_field_global_white(self): if hasattr(self, '_m_has_field_global_white'): return self._m_has_field_global_white self._m_has_field_global_white = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_white', None) @property def has_field_prefab_and_hint_white(self): if hasattr(self, '_m_has_field_prefab_and_hint_white'): return self._m_has_field_prefab_and_hint_white self._m_has_field_prefab_and_hint_white = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_prefab_and_hint_white', None) @property def has_field_main_page_black(self): if hasattr(self, '_m_has_field_main_page_black'): return self._m_has_field_main_page_black self._m_has_field_main_page_black = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_page_black', None) @property def has_field_dialog_black(self): if hasattr(self, '_m_has_field_dialog_black'): return self._m_has_field_dialog_black self._m_has_field_dialog_black = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dialog_black', None) class LanV2projectionMotionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGearType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GearType, self.data.value) return getattr(self, '_m_value', None) class StandDirectionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ModifierTimeScaleComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root)) class HuntingRefreshCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumHuntingRefreshCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ActivityArenaChallengeLevelInfoExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSDeviceAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.DeviceAction(self._io, self, self._root) class ByHasChildGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id_array: self.config_id_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) if self.has_field_force_by_caster: self.force_by_caster = self._io.read_u1() if self.has_field_check_entity_alive: self.check_entity_alive = self._io.read_u1() @property def has_field_check_entity_alive(self): if hasattr(self, '_m_has_field_check_entity_alive'): return self._m_has_field_check_entity_alive self._m_has_field_check_entity_alive = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_check_entity_alive', None) @property def has_field_config_id_array(self): if hasattr(self, '_m_has_field_config_id_array'): return self._m_has_field_config_id_array self._m_has_field_config_id_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id_array', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_force_by_caster(self): if hasattr(self, '_m_has_field_force_by_caster'): return self._m_has_field_force_by_caster self._m_has_field_force_by_caster = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_force_by_caster', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_compare_type', None) class DialogTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NativeStaticAllocator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarCurveExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiTacticBaseSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_condition: self.condition = Output.ConfigAiTacticCondition(self._io, self, self._root) if self.has_field_nerve_trigger: self.nerve_trigger = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_condition(self): if hasattr(self, '_m_has_field_condition'): return self._m_has_field_condition self._m_has_field_condition = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_condition', None) @property def has_field_nerve_trigger(self): if hasattr(self, '_m_has_field_nerve_trigger'): return self._m_has_field_nerve_trigger self._m_has_field_nerve_trigger = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_nerve_trigger', None) class ControlPartForwardByComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InputActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigTalentMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigTalentMixin(self._io, self, self._root) elif _on == 4: self.data = Output.UnlockControllerConditions(self._io, self, self._root) elif _on == 6: self.data = Output.ModifySkillCost(self._io, self, self._root) elif _on == 7: self.data = Output.ModifySkillPoint(self._io, self, self._root) elif _on == 1: self.data = Output.AddAbility(self._io, self, self._root) elif _on == 3: self.data = Output.UnlockTalentParam(self._io, self, self._root) elif _on == 5: self.data = Output.ModifySkillCd(self._io, self, self._root) elif _on == 8: self.data = Output.AddTalentExtraLevel(self._io, self, self._root) elif _on == 2: self.data = Output.ModifyAbility(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DisplayItemExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type_desc: self.type_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_display_type: self.display_type = Output.EnumDisplayItemType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type_desc(self): if hasattr(self, '_m_has_field_type_desc'): return self._m_has_field_type_desc self._m_has_field_type_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type_desc', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_dropable', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_use_level', None) @property def has_field_display_type(self): if hasattr(self, '_m_has_field_display_type'): return self._m_has_field_display_type self._m_has_field_display_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_display_type', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_item_type', None) class KvpOfDictAuxTypesStringConfigPerfNumberItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberItemOverrideInfo(self._io, self, self._root) class AvatarExitFocus(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_keep_rotation: self.keep_rotation = self._io.read_u1() @property def has_field_keep_rotation(self): if hasattr(self, '_m_has_field_keep_rotation'): return self._m_has_field_keep_rotation self._m_has_field_keep_rotation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_keep_rotation', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RoguelikeCardLabelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuideNavigationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideNavigationType, self.data.value) return getattr(self, '_m_value', None) class TowerCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WorldAreaLevelupAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumWorldAreaLevelupActionType(self._io, self, self._root) if self.has_field_param1_vec: self.param1_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_param2_vec: self.param2_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1_vec(self): if hasattr(self, '_m_has_field_param1_vec'): return self._m_has_field_param1_vec self._m_has_field_param1_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1_vec', None) @property def has_field_param2_vec(self): if hasattr(self, '_m_has_field_param2_vec'): return self._m_has_field_param2_vec self._m_has_field_param2_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2_vec', None) class EnumGuestButtonShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuestButtonShowType, self.data.value) return getattr(self, '_m_value', None) class LunaRiteQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMainQuestBrief(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series: self.series = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_main_quest_tag: self.main_quest_tag = Output.EnumMainQuestTagType(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suggest_track_main_quest_list: self.suggest_track_main_quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_id_list: self.reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_special_show_reward_id: self.special_show_reward_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_cond_id_list: self.special_show_cond_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_quest_id: self.special_show_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_quests: self.sub_quests = Output.ArrayOfConfigQuestSchemeLengthU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_series(self): if hasattr(self, '_m_has_field_series'): return self._m_has_field_series self._m_has_field_series = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_series', None) @property def has_field_reward_id_list(self): if hasattr(self, '_m_has_field_reward_id_list'): return self._m_has_field_reward_id_list self._m_has_field_reward_id_list = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_reward_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_desc', None) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_task_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_special_show_reward_id(self): if hasattr(self, '_m_has_field_special_show_reward_id'): return self._m_has_field_special_show_reward_id self._m_has_field_special_show_reward_id = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_special_show_reward_id', None) @property def has_field_sub_quests(self): if hasattr(self, '_m_has_field_sub_quests'): return self._m_has_field_sub_quests self._m_has_field_sub_quests = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_sub_quests', None) @property def has_field_special_show_cond_id_list(self): if hasattr(self, '_m_has_field_special_show_cond_id_list'): return self._m_has_field_special_show_cond_id_list self._m_has_field_special_show_cond_id_list = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_special_show_cond_id_list', None) @property def has_field_special_show_quest_id(self): if hasattr(self, '_m_has_field_special_show_quest_id'): return self._m_has_field_special_show_quest_id self._m_has_field_special_show_quest_id = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_special_show_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_show_type', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_suggest_track_main_quest_list(self): if hasattr(self, '_m_has_field_suggest_track_main_quest_list'): return self._m_has_field_suggest_track_main_quest_list self._m_has_field_suggest_track_main_quest_list = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_suggest_track_main_quest_list', None) @property def has_field_main_quest_tag(self): if hasattr(self, '_m_has_field_main_quest_tag'): return self._m_has_field_main_quest_tag self._m_has_field_main_quest_tag = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_main_quest_tag', None) class KvpOfDictAuxTypesVlqBase128LeSConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigWwiseString(self._io, self, self._root) class SystemOpenUiConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) class FocusAssistanceGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ps4: self.ps4 = Output.FocusAssistance(self._io, self, self._root) if self.has_field_ps5: self.ps5 = Output.FocusAssistance(self._io, self, self._root) if self.has_field_other: self.other = Output.FocusAssistance(self._io, self, self._root) @property def has_field_ps4(self): if hasattr(self, '_m_has_field_ps4'): return self._m_has_field_ps4 self._m_has_field_ps4 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ps4', None) @property def has_field_ps5(self): if hasattr(self, '_m_has_field_ps5'): return self._m_has_field_ps5 self._m_has_field_ps5 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ps5', None) @property def has_field_other(self): if hasattr(self, '_m_has_field_other'): return self._m_has_field_other self._m_has_field_other = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_other', None) class EnumLoadingAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LoadingAreaType, self.data.value) return getattr(self, '_m_value', None) class EnumSmaaQuality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SmaaQuality, self.data.value) return getattr(self, '_m_value', None) class VoicePositioningComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PlatformMoveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_logic_move: self.is_logic_move = self._io.read_u1() if self.has_field_move_modifiers: self.move_modifiers = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_stop_modifiers: self.stop_modifiers = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_is_logic_move(self): if hasattr(self, '_m_has_field_is_logic_move'): return self._m_has_field_is_logic_move self._m_has_field_is_logic_move = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_logic_move', None) @property def has_field_move_modifiers(self): if hasattr(self, '_m_has_field_move_modifiers'): return self._m_has_field_move_modifiers self._m_has_field_move_modifiers = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_move_modifiers', None) @property def has_field_stop_modifiers(self): if hasattr(self, '_m_has_field_stop_modifiers'): return self._m_has_field_stop_modifiers self._m_has_field_stop_modifiers = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_stop_modifiers', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAudioGameViewState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_group_name: self.state_group_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_normal_state_value: self.normal_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_focused_state_value: self.focused_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_sneak_in_state_value: self.sneak_in_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_menu_state_value: self.menu_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_pause_menu_state_value: self.pause_menu_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dialog_state_value: self.dialog_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_video_state_value: self.video_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_element_view_state_value: self.element_view_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_music_game_solo_state_value: self.music_game_solo_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_music_game_free_play_state_value: self.music_game_free_play_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_ui_page_ignore_list: self.ui_page_ignore_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ui_page_ignore_list(self): if hasattr(self, '_m_has_field_ui_page_ignore_list'): return self._m_has_field_ui_page_ignore_list self._m_has_field_ui_page_ignore_list = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_ui_page_ignore_list', None) @property def has_field_music_game_solo_state_value(self): if hasattr(self, '_m_has_field_music_game_solo_state_value'): return self._m_has_field_music_game_solo_state_value self._m_has_field_music_game_solo_state_value = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_music_game_solo_state_value', None) @property def has_field_dialog_state_value(self): if hasattr(self, '_m_has_field_dialog_state_value'): return self._m_has_field_dialog_state_value self._m_has_field_dialog_state_value = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_dialog_state_value', None) @property def has_field_video_state_value(self): if hasattr(self, '_m_has_field_video_state_value'): return self._m_has_field_video_state_value self._m_has_field_video_state_value = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_video_state_value', None) @property def has_field_state_group_name(self): if hasattr(self, '_m_has_field_state_group_name'): return self._m_has_field_state_group_name self._m_has_field_state_group_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_state_group_name', None) @property def has_field_normal_state_value(self): if hasattr(self, '_m_has_field_normal_state_value'): return self._m_has_field_normal_state_value self._m_has_field_normal_state_value = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_normal_state_value', None) @property def has_field_pause_menu_state_value(self): if hasattr(self, '_m_has_field_pause_menu_state_value'): return self._m_has_field_pause_menu_state_value self._m_has_field_pause_menu_state_value = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_pause_menu_state_value', None) @property def has_field_music_game_free_play_state_value(self): if hasattr(self, '_m_has_field_music_game_free_play_state_value'): return self._m_has_field_music_game_free_play_state_value self._m_has_field_music_game_free_play_state_value = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_music_game_free_play_state_value', None) @property def has_field_sneak_in_state_value(self): if hasattr(self, '_m_has_field_sneak_in_state_value'): return self._m_has_field_sneak_in_state_value self._m_has_field_sneak_in_state_value = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_sneak_in_state_value', None) @property def has_field_element_view_state_value(self): if hasattr(self, '_m_has_field_element_view_state_value'): return self._m_has_field_element_view_state_value self._m_has_field_element_view_state_value = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_element_view_state_value', None) @property def has_field_menu_state_value(self): if hasattr(self, '_m_has_field_menu_state_value'): return self._m_has_field_menu_state_value self._m_has_field_menu_state_value = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_menu_state_value', None) @property def has_field_focused_state_value(self): if hasattr(self, '_m_has_field_focused_state_value'): return self._m_has_field_focused_state_value self._m_has_field_focused_state_value = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_focused_state_value', None) class ConfigQteStepCameraMoveAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_exit_return_back: self.exit_return_back = self._io.read_u1() @property def has_field_exit_return_back(self): if hasattr(self, '_m_has_field_exit_return_back'): return self._m_has_field_exit_return_back self._m_has_field_exit_return_back = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_exit_return_back', None) @property def inter_action(self): if hasattr(self, '_m_inter_action'): return self._m_inter_action self._m_inter_action = self.base.inter_action return getattr(self, '_m_inter_action', None) @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) class DictOfEnumConfigKeyCodeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumConfigKeyCodeAuxTypesString(self._io, self, self._root)) class GuestButtonShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PlayerCustomOptionSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_setting_entry: self.setting_entry = Output.EnumGraphicsSettingEntryType(self._io, self, self._root) if self.has_field_custom_config_map: self.custom_config_map = Output.DictOfAuxTypesStringPlayerCustomOptionConfig(self._io, self, self._root) if self.has_field_option_name_type: self.option_name_type = Output.EnumPerfOptionTextType(self._io, self, self._root) if self.has_field_sort_type: self.sort_type = Output.EnumConfigGraphicSettingEntrySortType(self._io, self, self._root) @property def has_field_setting_entry(self): if hasattr(self, '_m_has_field_setting_entry'): return self._m_has_field_setting_entry self._m_has_field_setting_entry = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_setting_entry', None) @property def has_field_custom_config_map(self): if hasattr(self, '_m_has_field_custom_config_map'): return self._m_has_field_custom_config_map self._m_has_field_custom_config_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_custom_config_map', None) @property def has_field_option_name_type(self): if hasattr(self, '_m_has_field_option_name_type'): return self._m_has_field_option_name_type self._m_has_field_option_name_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_option_name_type', None) @property def has_field_sort_type(self): if hasattr(self, '_m_has_field_sort_type'): return self._m_has_field_sort_type self._m_has_field_sort_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_sort_type', None) class SectrCityLevelTagOffsetInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level_tag_id: self.level_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_delta_offset: self.city_delta_offset = Output.Vector(self._io, self, self._root) if self.has_field_city_delta_rotation: self.city_delta_rotation = Output.Vector(self._io, self, self._root) @property def has_field_level_tag_id(self): if hasattr(self, '_m_has_field_level_tag_id'): return self._m_has_field_level_tag_id self._m_has_field_level_tag_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level_tag_id', None) @property def has_field_city_delta_offset(self): if hasattr(self, '_m_has_field_city_delta_offset'): return self._m_has_field_city_delta_offset self._m_has_field_city_delta_offset = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_city_delta_offset', None) @property def has_field_city_delta_rotation(self): if hasattr(self, '_m_has_field_city_delta_rotation'): return self._m_has_field_city_delta_rotation self._m_has_field_city_delta_rotation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_city_delta_rotation', None) class ExpeditionActivityPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigLevel1worldAreaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevel1worldArea(self._io, self, self._root)) class EnumCondfigAiRangeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CondfigAiRangeType, self.data.value) return getattr(self, '_m_value', None) class ConfigTornadoZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shape_name: self.shape_name = AuxTypes.String(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_dir: self.dir = Output.Vector(self._io, self, self._root) if self.has_field_strength: self.strength = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_attenuation: self.attenuation = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_inner_radius: self.inner_radius = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_force_growth: self.force_growth = self._io.read_f4le() if self.has_field_force_fallen: self.force_fallen = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_force_fallen(self): if hasattr(self, '_m_has_field_force_fallen'): return self._m_has_field_force_fallen self._m_has_field_force_fallen = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_force_fallen', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_max_num', None) @property def has_field_shape_name(self): if hasattr(self, '_m_has_field_shape_name'): return self._m_has_field_shape_name self._m_has_field_shape_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_shape_name', None) @property def has_field_dir(self): if hasattr(self, '_m_has_field_dir'): return self._m_has_field_dir self._m_has_field_dir = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_dir', None) @property def has_field_strength(self): if hasattr(self, '_m_has_field_strength'): return self._m_has_field_strength self._m_has_field_strength = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_strength', None) @property def has_field_inner_radius(self): if hasattr(self, '_m_has_field_inner_radius'): return self._m_has_field_inner_radius self._m_has_field_inner_radius = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_inner_radius', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_force_growth(self): if hasattr(self, '_m_has_field_force_growth'): return self._m_has_field_force_growth self._m_has_field_force_growth = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_force_growth', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_modifier_name', None) class ActivitySalesmanExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CreateTile(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tile_name: self.tile_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attack_pattern: self.attack_pattern = Output.DispConfigBaseAttackPattern(self._io, self, self._root) @property def has_field_tile_name(self): if hasattr(self, '_m_has_field_tile_name'): return self._m_has_field_tile_name self._m_has_field_tile_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tile_name', None) @property def has_field_attack_pattern(self): if hasattr(self, '_m_has_field_attack_pattern'): return self._m_has_field_attack_pattern self._m_has_field_attack_pattern = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attack_pattern', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumOfferingActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OfferingActionType, self.data.value) return getattr(self, '_m_value', None) class TriggerCrystalLinkAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ByAnimatorBool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_parameter', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class UintIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWeatherEffectControlTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MiracleRingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_miracle_value: self.miracle_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_miracle_tag: self.miracle_tag = Output.ArrayOfEnumMiracleTagLengthS(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_miracle_value(self): if hasattr(self, '_m_has_field_miracle_value'): return self._m_has_field_miracle_value self._m_has_field_miracle_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_miracle_value', None) @property def has_field_miracle_tag(self): if hasattr(self, '_m_has_field_miracle_tag'): return self._m_has_field_miracle_tag self._m_has_field_miracle_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_miracle_tag', None) class ConfigSliceFrameWatch(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_amortized_tick_massive_entity_budget: self.amortized_tick_massive_entity_budget = self._io.read_f4le() if self.has_field_shared_slice_frame_game_system_time: self.shared_slice_frame_game_system_time = self._io.read_f4le() if self.has_field_resources_manager_asset_job_min_time: self.resources_manager_asset_job_min_time = self._io.read_f4le() if self.has_field_resources_manager_asset_job_max_time: self.resources_manager_asset_job_max_time = self._io.read_f4le() if self.has_field_resources_manager_instantiate_min_time: self.resources_manager_instantiate_min_time = self._io.read_f4le() if self.has_field_resources_manager_instantiate_max_time: self.resources_manager_instantiate_max_time = self._io.read_f4le() if self.has_field_resources_manager_unload_min_time: self.resources_manager_unload_min_time = self._io.read_f4le() if self.has_field_resources_manager_unload_max_time: self.resources_manager_unload_max_time = self._io.read_f4le() if self.has_field_resources_manager_instantiate_job_time: self.resources_manager_instantiate_job_time = self._io.read_f4le() if self.has_field_level_appear_disappear_time_ms_default: self.level_appear_disappear_time_ms_default = self._io.read_f4le() if self.has_field_level_appear_disappear_wrr_weight: self.level_appear_disappear_wrr_weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_init_component_common_slicing_time_default: self.init_component_common_slicing_time_default = self._io.read_f4le() if self.has_field_remove_entity_time_ms_default: self.remove_entity_time_ms_default = self._io.read_f4le() if self.has_field_remove_enity_wrr_weight: self.remove_enity_wrr_weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_sectr_wrr_weight_default: self.sectr_wrr_weight_default = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_timer_manager_time_ms: self.timer_manager_time_ms = self._io.read_f4le() if self.has_field_use_legacy_generic_object_pool: self.use_legacy_generic_object_pool = self._io.read_u1() if self.has_field_significance_task_thread_lod: self.significance_task_thread_lod = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_loading_use_sync_load: self.loading_use_sync_load = self._io.read_u1() @property def has_field_resources_manager_unload_max_time(self): if hasattr(self, '_m_has_field_resources_manager_unload_max_time'): return self._m_has_field_resources_manager_unload_max_time self._m_has_field_resources_manager_unload_max_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_resources_manager_unload_max_time', None) @property def has_field_resources_manager_unload_min_time(self): if hasattr(self, '_m_has_field_resources_manager_unload_min_time'): return self._m_has_field_resources_manager_unload_min_time self._m_has_field_resources_manager_unload_min_time = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_resources_manager_unload_min_time', None) @property def has_field_significance_task_thread_lod(self): if hasattr(self, '_m_has_field_significance_task_thread_lod'): return self._m_has_field_significance_task_thread_lod self._m_has_field_significance_task_thread_lod = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_significance_task_thread_lod', None) @property def has_field_resources_manager_asset_job_max_time(self): if hasattr(self, '_m_has_field_resources_manager_asset_job_max_time'): return self._m_has_field_resources_manager_asset_job_max_time self._m_has_field_resources_manager_asset_job_max_time = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_resources_manager_asset_job_max_time', None) @property def has_field_remove_enity_wrr_weight(self): if hasattr(self, '_m_has_field_remove_enity_wrr_weight'): return self._m_has_field_remove_enity_wrr_weight self._m_has_field_remove_enity_wrr_weight = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_remove_enity_wrr_weight', None) @property def has_field_resources_manager_instantiate_job_time(self): if hasattr(self, '_m_has_field_resources_manager_instantiate_job_time'): return self._m_has_field_resources_manager_instantiate_job_time self._m_has_field_resources_manager_instantiate_job_time = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_resources_manager_instantiate_job_time', None) @property def has_field_resources_manager_instantiate_min_time(self): if hasattr(self, '_m_has_field_resources_manager_instantiate_min_time'): return self._m_has_field_resources_manager_instantiate_min_time self._m_has_field_resources_manager_instantiate_min_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_resources_manager_instantiate_min_time', None) @property def has_field_level_appear_disappear_wrr_weight(self): if hasattr(self, '_m_has_field_level_appear_disappear_wrr_weight'): return self._m_has_field_level_appear_disappear_wrr_weight self._m_has_field_level_appear_disappear_wrr_weight = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_level_appear_disappear_wrr_weight', None) @property def has_field_amortized_tick_massive_entity_budget(self): if hasattr(self, '_m_has_field_amortized_tick_massive_entity_budget'): return self._m_has_field_amortized_tick_massive_entity_budget self._m_has_field_amortized_tick_massive_entity_budget = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_amortized_tick_massive_entity_budget', None) @property def has_field_level_appear_disappear_time_ms_default(self): if hasattr(self, '_m_has_field_level_appear_disappear_time_ms_default'): return self._m_has_field_level_appear_disappear_time_ms_default self._m_has_field_level_appear_disappear_time_ms_default = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_level_appear_disappear_time_ms_default', None) @property def has_field_init_component_common_slicing_time_default(self): if hasattr(self, '_m_has_field_init_component_common_slicing_time_default'): return self._m_has_field_init_component_common_slicing_time_default self._m_has_field_init_component_common_slicing_time_default = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_init_component_common_slicing_time_default', None) @property def has_field_timer_manager_time_ms(self): if hasattr(self, '_m_has_field_timer_manager_time_ms'): return self._m_has_field_timer_manager_time_ms self._m_has_field_timer_manager_time_ms = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_timer_manager_time_ms', None) @property def has_field_use_legacy_generic_object_pool(self): if hasattr(self, '_m_has_field_use_legacy_generic_object_pool'): return self._m_has_field_use_legacy_generic_object_pool self._m_has_field_use_legacy_generic_object_pool = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_use_legacy_generic_object_pool', None) @property def has_field_sectr_wrr_weight_default(self): if hasattr(self, '_m_has_field_sectr_wrr_weight_default'): return self._m_has_field_sectr_wrr_weight_default self._m_has_field_sectr_wrr_weight_default = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_sectr_wrr_weight_default', None) @property def has_field_resources_manager_asset_job_min_time(self): if hasattr(self, '_m_has_field_resources_manager_asset_job_min_time'): return self._m_has_field_resources_manager_asset_job_min_time self._m_has_field_resources_manager_asset_job_min_time = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_resources_manager_asset_job_min_time', None) @property def has_field_remove_entity_time_ms_default(self): if hasattr(self, '_m_has_field_remove_entity_time_ms_default'): return self._m_has_field_remove_entity_time_ms_default self._m_has_field_remove_entity_time_ms_default = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_remove_entity_time_ms_default', None) @property def has_field_shared_slice_frame_game_system_time(self): if hasattr(self, '_m_has_field_shared_slice_frame_game_system_time'): return self._m_has_field_shared_slice_frame_game_system_time self._m_has_field_shared_slice_frame_game_system_time = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_shared_slice_frame_game_system_time', None) @property def has_field_loading_use_sync_load(self): if hasattr(self, '_m_has_field_loading_use_sync_load'): return self._m_has_field_loading_use_sync_load self._m_has_field_loading_use_sync_load = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_loading_use_sync_load', None) @property def has_field_resources_manager_instantiate_max_time(self): if hasattr(self, '_m_has_field_resources_manager_instantiate_max_time'): return self._m_has_field_resources_manager_instantiate_max_time self._m_has_field_resources_manager_instantiate_max_time = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_resources_manager_instantiate_max_time', None) class ConfigClimateCommon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_length: self.length = self._io.read_f4le() if self.has_field_threshold_ratio: self.threshold_ratio = self._io.read_f4le() if self.has_field_debuffs: self.debuffs = Output.DictOfEnumJsonClimateTypeArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_area_buffs: self.area_buffs = Output.DictOfEnumJsonClimateTypeArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_miscs: self.miscs = Output.ConfigClimateMisc(self._io, self, self._root) if self.has_field_perform: self.perform = Output.ConfigClimatePerform(self._io, self, self._root) if self.has_field_ui_warning_ratio: self.ui_warning_ratio = self._io.read_f4le() if self.has_field_ui_len_weak_intensity: self.ui_len_weak_intensity = self._io.read_f4le() if self.has_field_ui_len_lerp_speed: self.ui_len_lerp_speed = self._io.read_f4le() @property def has_field_threshold_ratio(self): if hasattr(self, '_m_has_field_threshold_ratio'): return self._m_has_field_threshold_ratio self._m_has_field_threshold_ratio = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_threshold_ratio', None) @property def has_field_ui_len_lerp_speed(self): if hasattr(self, '_m_has_field_ui_len_lerp_speed'): return self._m_has_field_ui_len_lerp_speed self._m_has_field_ui_len_lerp_speed = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_ui_len_lerp_speed', None) @property def has_field_ui_warning_ratio(self): if hasattr(self, '_m_has_field_ui_warning_ratio'): return self._m_has_field_ui_warning_ratio self._m_has_field_ui_warning_ratio = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ui_warning_ratio', None) @property def has_field_miscs(self): if hasattr(self, '_m_has_field_miscs'): return self._m_has_field_miscs self._m_has_field_miscs = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_miscs', None) @property def has_field_ui_len_weak_intensity(self): if hasattr(self, '_m_has_field_ui_len_weak_intensity'): return self._m_has_field_ui_len_weak_intensity self._m_has_field_ui_len_weak_intensity = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_ui_len_weak_intensity', None) @property def has_field_debuffs(self): if hasattr(self, '_m_has_field_debuffs'): return self._m_has_field_debuffs self._m_has_field_debuffs = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_debuffs', None) @property def has_field_perform(self): if hasattr(self, '_m_has_field_perform'): return self._m_has_field_perform self._m_has_field_perform = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_perform', None) @property def has_field_area_buffs(self): if hasattr(self, '_m_has_field_area_buffs'): return self._m_has_field_area_buffs self._m_has_field_area_buffs = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_area_buffs', None) @property def has_field_length(self): if hasattr(self, '_m_has_field_length'): return self._m_has_field_length self._m_has_field_length = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_length', None) class RotAngleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumOverflowTransformType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OverflowTransformType, self.data.value) return getattr(self, '_m_value', None) class FireworksLaunchParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiFleeOnBlockAvatarLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_trigger_distance: self.trigger_distance = self._io.read_f4le() if self.has_field_flee_angle: self.flee_angle = self._io.read_f4le() if self.has_field_flee_distance_min: self.flee_distance_min = self._io.read_f4le() if self.has_field_flee_distance_max: self.flee_distance_max = self._io.read_f4le() if self.has_field_neuron_trigger_cd: self.neuron_trigger_cd = self._io.read_f4le() @property def has_field_flee_angle(self): if hasattr(self, '_m_has_field_flee_angle'): return self._m_has_field_flee_angle self._m_has_field_flee_angle = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_flee_angle', None) @property def has_field_trigger_distance(self): if hasattr(self, '_m_has_field_trigger_distance'): return self._m_has_field_trigger_distance self._m_has_field_trigger_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trigger_distance', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_flee_distance_max(self): if hasattr(self, '_m_has_field_flee_distance_max'): return self._m_has_field_flee_distance_max self._m_has_field_flee_distance_max = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_flee_distance_max', None) @property def has_field_neuron_trigger_cd(self): if hasattr(self, '_m_has_field_neuron_trigger_cd'): return self._m_has_field_neuron_trigger_cd self._m_has_field_neuron_trigger_cd = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_neuron_trigger_cd', None) @property def has_field_flee_distance_min(self): if hasattr(self, '_m_has_field_flee_distance_min'): return self._m_has_field_flee_distance_min self._m_has_field_flee_distance_min = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_flee_distance_min', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class PushTipsCodexTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OptionalLimitConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_unlimited: self.is_unlimited = self._io.read_u1() if self.has_field_limit_count: self.limit_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_unlimited(self): if hasattr(self, '_m_has_field_is_unlimited'): return self._m_has_field_is_unlimited self._m_has_field_is_unlimited = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_unlimited', None) @property def has_field_limit_count(self): if hasattr(self, '_m_has_field_limit_count'): return self._m_has_field_limit_count self._m_has_field_limit_count = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_limit_count', None) class EnumAnimatorParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimatorParamType, self.data.value) return getattr(self, '_m_value', None) class EnumRoutineFinishType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoutineFinishType, self.data.value) return getattr(self, '_m_value', None) class TriggerExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OptionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NightCrowArgumentExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GadgetTitleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDungeonEntrySatisfiedConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonEntrySatisfiedConditionType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideTheatreMechanicusInfoSelectCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_select: self.is_select = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_select(self): if hasattr(self, '_m_has_field_is_select'): return self._m_has_field_is_select self._m_has_field_is_select = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_select', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class DialogGroupSchemeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfNumberItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberItemOptionArrayInfo(self._io, self, self._root) class CodexQuestItemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FollowTargetComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCutsceneContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumCutsceneIndexType(self._io, self, self._root) if self.has_field_enable_force_streaming: self.enable_force_streaming = self._io.read_u1() if self.has_field_cutscene_config: self.cutscene_config = Output.ConfigTimeline(self._io, self, self._root) if self.has_field_video_config: self.video_config = Output.ConfigVideo(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_enable_force_streaming(self): if hasattr(self, '_m_has_field_enable_force_streaming'): return self._m_has_field_enable_force_streaming self._m_has_field_enable_force_streaming = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable_force_streaming', None) @property def has_field_cutscene_config(self): if hasattr(self, '_m_has_field_cutscene_config'): return self._m_has_field_cutscene_config self._m_has_field_cutscene_config = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cutscene_config', None) @property def has_field_video_config(self): if hasattr(self, '_m_has_field_video_config'): return self._m_has_field_video_config self._m_has_field_video_config = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_video_config', None) class ConfigGuideHideandSeekSkillCategoryCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuidePageCheckBaseCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_select: self.is_select = self._io.read_u1() @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_index', None) @property def has_field_is_select(self): if hasattr(self, '_m_has_field_is_select'): return self._m_has_field_is_select self._m_has_field_is_select = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_select', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class QuestGlobalVarConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopmallGoodsSaleConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_goods_id: self.goods_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_scoin: self.discount_scoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_hcoin: self.discount_hcoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_mcoin: self.discount_mcoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_rate: self.discount_rate = self._io.read_f4le() if self.has_field_discount_begin_time: self.discount_begin_time = AuxTypes.String(self._io, self, self._root) if self.has_field_discount_end_time: self.discount_end_time = AuxTypes.String(self._io, self, self._root) if self.has_field_discount_begin_timestamp: self.discount_begin_timestamp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_end_timestamp: self.discount_end_timestamp = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_discount_rate(self): if hasattr(self, '_m_has_field_discount_rate'): return self._m_has_field_discount_rate self._m_has_field_discount_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_discount_rate', None) @property def has_field_discount_begin_timestamp(self): if hasattr(self, '_m_has_field_discount_begin_timestamp'): return self._m_has_field_discount_begin_timestamp self._m_has_field_discount_begin_timestamp = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_discount_begin_timestamp', None) @property def has_field_discount_hcoin(self): if hasattr(self, '_m_has_field_discount_hcoin'): return self._m_has_field_discount_hcoin self._m_has_field_discount_hcoin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_discount_hcoin', None) @property def has_field_discount_mcoin(self): if hasattr(self, '_m_has_field_discount_mcoin'): return self._m_has_field_discount_mcoin self._m_has_field_discount_mcoin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_discount_mcoin', None) @property def has_field_goods_id(self): if hasattr(self, '_m_has_field_goods_id'): return self._m_has_field_goods_id self._m_has_field_goods_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_goods_id', None) @property def has_field_discount_end_time(self): if hasattr(self, '_m_has_field_discount_end_time'): return self._m_has_field_discount_end_time self._m_has_field_discount_end_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_discount_end_time', None) @property def has_field_discount_end_timestamp(self): if hasattr(self, '_m_has_field_discount_end_timestamp'): return self._m_has_field_discount_end_timestamp self._m_has_field_discount_end_timestamp = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_discount_end_timestamp', None) @property def has_field_discount_scoin(self): if hasattr(self, '_m_has_field_discount_scoin'): return self._m_has_field_discount_scoin self._m_has_field_discount_scoin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_discount_scoin', None) @property def has_field_discount_begin_time(self): if hasattr(self, '_m_has_field_discount_begin_time'): return self._m_has_field_discount_begin_time self._m_has_field_discount_begin_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_discount_begin_time', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class DropNodeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigQteButtonCountDownValueCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseCond(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_order_type: self.order_type = Output.EnumOrderingType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_order_type(self): if hasattr(self, '_m_has_field_order_type'): return self._m_has_field_order_type self._m_has_field_order_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_order_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def cond_type(self): if hasattr(self, '_m_cond_type'): return self._m_cond_type self._m_cond_type = self.base.cond_type return getattr(self, '_m_cond_type', None) class EnumReliquaryMainAffixName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReliquaryMainAffixName, self.data.value) return getattr(self, '_m_value', None) class EnumElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ElementType, self.data.value) return getattr(self, '_m_value', None) class AnimalCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAnimalCodexType(self._io, self, self._root) if self.has_field_describe_id: self.describe_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_seen_active: self.is_seen_active = self._io.read_u1() if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() if self.has_field_show_only_unlocked: self.show_only_unlocked = self._io.read_u1() if self.has_field_sub_type: self.sub_type = Output.EnumAnimalCodexSubType(self._io, self, self._root) if self.has_field_count_type: self.count_type = Output.EnumAnimalCodexCountType(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_model_path: self.model_path = AuxTypes.String(self._io, self, self._root) if self.has_field_push_tips_codex_id: self.push_tips_codex_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sub_type(self): if hasattr(self, '_m_has_field_sub_type'): return self._m_has_field_sub_type self._m_has_field_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_sub_type', None) @property def has_field_count_type(self): if hasattr(self, '_m_has_field_count_type'): return self._m_has_field_count_type self._m_has_field_count_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_count_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_show_only_unlocked(self): if hasattr(self, '_m_has_field_show_only_unlocked'): return self._m_has_field_show_only_unlocked self._m_has_field_show_only_unlocked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_only_unlocked', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_model_path(self): if hasattr(self, '_m_has_field_model_path'): return self._m_has_field_model_path self._m_has_field_model_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_model_path', None) @property def has_field_push_tips_codex_id(self): if hasattr(self, '_m_has_field_push_tips_codex_id'): return self._m_has_field_push_tips_codex_id self._m_has_field_push_tips_codex_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_push_tips_codex_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_describe_id(self): if hasattr(self, '_m_has_field_describe_id'): return self._m_has_field_describe_id self._m_has_field_describe_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_describe_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_is_seen_active(self): if hasattr(self, '_m_has_field_is_seen_active'): return self._m_has_field_is_seen_active self._m_has_field_is_seen_active = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_seen_active', None) class EnumExtraAbilityState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExtraAbilityState, self.data.value) return getattr(self, '_m_value', None) class BookSuitExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suit_name: self.suit_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_suit_name(self): if hasattr(self, '_m_has_field_suit_name'): return self._m_has_field_suit_name self._m_has_field_suit_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_suit_name', None) class InvestigationMonsterMapMarkCreateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGivingType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GivingType, self.data.value) return getattr(self, '_m_value', None) class GadgetUiItemShowCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChallengeRecordType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChallengeRecordType, self.data.value) return getattr(self, '_m_value', None) class AvatarExitCameraShot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shot_type: self.shot_type = Output.EnumAbilityCameraShotType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_shot_type(self): if hasattr(self, '_m_has_field_shot_type'): return self._m_has_field_shot_type self._m_has_field_shot_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shot_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ActivityChessLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChangeShieldValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shield_hp_ratio: self.shield_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp: self.shield_hp = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_shield_by_hp_ratio: self.max_shield_by_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_shield_hp: self.max_shield_hp = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_refresh_time: self.refresh_time = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_max_shield_hp(self): if hasattr(self, '_m_has_field_max_shield_hp'): return self._m_has_field_max_shield_hp self._m_has_field_max_shield_hp = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_shield_hp', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_shield_hp_ratio(self): if hasattr(self, '_m_has_field_shield_hp_ratio'): return self._m_has_field_shield_hp_ratio self._m_has_field_shield_hp_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shield_hp_ratio', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_refresh_time(self): if hasattr(self, '_m_has_field_refresh_time'): return self._m_has_field_refresh_time self._m_has_field_refresh_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_refresh_time', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_shield_hp(self): if hasattr(self, '_m_has_field_shield_hp'): return self._m_has_field_shield_hp self._m_has_field_shield_hp = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shield_hp', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_max_shield_by_hp_ratio(self): if hasattr(self, '_m_has_field_max_shield_by_hp_ratio'): return self._m_has_field_max_shield_by_hp_ratio self._m_has_field_max_shield_by_hp_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_shield_by_hp_ratio', None) class CustomLevelUiConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMarkIcon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_material_index: self.material_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_type: self.mark_type = Output.EnumMarkType(self._io, self, self._root) if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ignore_raycast_on_map: self.ignore_raycast_on_map = self._io.read_u1() if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.String(self._io, self, self._root) if self.has_field_mark_layer: self.mark_layer = Output.EnumMarkOrder(self._io, self, self._root) if self.has_field_visibility_on_radar: self.visibility_on_radar = Output.EnumMarkVisibilityType(self._io, self, self._root) if self.has_field_visibility_on_map: self.visibility_on_map = Output.EnumMarkVisibilityType(self._io, self, self._root) if self.has_field_show_height_on_radar: self.show_height_on_radar = self._io.read_u1() if self.has_field_show_on_locked_area: self.show_on_locked_area = self._io.read_u1() if self.has_field_plugin_icon_type: self.plugin_icon_type = Output.EnumMarkPluginIconType(self._io, self, self._root) if self.has_field_fallback_mark_tips_type: self.fallback_mark_tips_type = Output.EnumFallbackMarkTipsType(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_icon_name', None) @property def has_field_plugin_icon_type(self): if hasattr(self, '_m_has_field_plugin_icon_type'): return self._m_has_field_plugin_icon_type self._m_has_field_plugin_icon_type = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_plugin_icon_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_desc', None) @property def has_field_mark_layer(self): if hasattr(self, '_m_has_field_mark_layer'): return self._m_has_field_mark_layer self._m_has_field_mark_layer = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_mark_layer', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_effect_name', None) @property def has_field_fallback_mark_tips_type(self): if hasattr(self, '_m_has_field_fallback_mark_tips_type'): return self._m_has_field_fallback_mark_tips_type self._m_has_field_fallback_mark_tips_type = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_fallback_mark_tips_type', None) @property def has_field_ignore_raycast_on_map(self): if hasattr(self, '_m_has_field_ignore_raycast_on_map'): return self._m_has_field_ignore_raycast_on_map self._m_has_field_ignore_raycast_on_map = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_ignore_raycast_on_map', None) @property def has_field_visibility_on_radar(self): if hasattr(self, '_m_has_field_visibility_on_radar'): return self._m_has_field_visibility_on_radar self._m_has_field_visibility_on_radar = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_visibility_on_radar', None) @property def has_field_mark_type(self): if hasattr(self, '_m_has_field_mark_type'): return self._m_has_field_mark_type self._m_has_field_mark_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_mark_type', None) @property def has_field_material_index(self): if hasattr(self, '_m_has_field_material_index'): return self._m_has_field_material_index self._m_has_field_material_index = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_material_index', None) @property def has_field_show_height_on_radar(self): if hasattr(self, '_m_has_field_show_height_on_radar'): return self._m_has_field_show_height_on_radar self._m_has_field_show_height_on_radar = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_show_height_on_radar', None) @property def has_field_visibility_on_map(self): if hasattr(self, '_m_has_field_visibility_on_map'): return self._m_has_field_visibility_on_map self._m_has_field_visibility_on_map = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_visibility_on_map', None) @property def has_field_show_on_locked_area(self): if hasattr(self, '_m_has_field_show_on_locked_area'): return self._m_has_field_show_on_locked_area self._m_has_field_show_on_locked_area = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_show_on_locked_area', None) class Ps4groupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFace(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_character_name: self.character_name = AuxTypes.String(self._io, self, self._root) if self.has_field_base_face_animation: self.base_face_animation = AuxTypes.String(self._io, self, self._root) if self.has_field_interval_face_animation: self.interval_face_animation = AuxTypes.String(self._io, self, self._root) if self.has_field_min_interval: self.min_interval = self._io.read_f4le() if self.has_field_max_interval: self.max_interval = self._io.read_f4le() @property def has_field_character_name(self): if hasattr(self, '_m_has_field_character_name'): return self._m_has_field_character_name self._m_has_field_character_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_character_name', None) @property def has_field_interval_face_animation(self): if hasattr(self, '_m_has_field_interval_face_animation'): return self._m_has_field_interval_face_animation self._m_has_field_interval_face_animation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_interval_face_animation', None) @property def has_field_min_interval(self): if hasattr(self, '_m_has_field_min_interval'): return self._m_has_field_min_interval self._m_has_field_min_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_interval', None) @property def has_field_base_face_animation(self): if hasattr(self, '_m_has_field_base_face_animation'): return self._m_has_field_base_face_animation self._m_has_field_base_face_animation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_base_face_animation', None) @property def has_field_max_interval(self): if hasattr(self, '_m_has_field_max_interval'): return self._m_has_field_max_interval self._m_has_field_max_interval = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_interval', None) class ExcelMailTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuideHasAvatarConType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideHasAvatarConType, self.data.value) return getattr(self, '_m_value', None) class EnumRogueCellType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueCellType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfPropValConfigLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.PropValConfig(self._io, self, self._root)) class ConfigFluctuatedValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_upper: self.upper = self._io.read_f4le() if self.has_field_lower: self.lower = self._io.read_f4le() @property def has_field_upper(self): if hasattr(self, '_m_has_field_upper'): return self._m_has_field_upper self._m_has_field_upper = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_upper', None) @property def has_field_lower(self): if hasattr(self, '_m_has_field_lower'): return self._m_has_field_lower self._m_has_field_lower = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lower', None) class GuideMultiPlayerModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigParabolaBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_angle_off_hor: self.angle_off_hor = self._io.read_f4le() if self.has_field_gravity_of_acceleration: self.gravity_of_acceleration = self._io.read_f4le() if self.has_field_correction: self.correction = Output.DispConfigMoveCorrection(self._io, self, self._root) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def has_field_gravity_of_acceleration(self): if hasattr(self, '_m_has_field_gravity_of_acceleration'): return self._m_has_field_gravity_of_acceleration self._m_has_field_gravity_of_acceleration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gravity_of_acceleration', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def has_field_angle_off_hor(self): if hasattr(self, '_m_has_field_angle_off_hor'): return self._m_has_field_angle_off_hor self._m_has_field_angle_off_hor = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angle_off_hor', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_correction(self): if hasattr(self, '_m_has_field_correction'): return self._m_has_field_correction self._m_has_field_correction = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_correction', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ActivitySummerTimeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAnimatorBoolean(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_normalize_start: self.normalize_start = self._io.read_f4le() if self.has_field_normalize_end: self.normalize_end = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_normalize_start(self): if hasattr(self, '_m_has_field_normalize_start'): return self._m_has_field_normalize_start self._m_has_field_normalize_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_normalize_start', None) @property def has_field_normalize_end(self): if hasattr(self, '_m_has_field_normalize_end'): return self._m_has_field_normalize_end self._m_has_field_normalize_end = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_normalize_end', None) class ConfigWidgetToyOpenPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_page_name: self.page_name = AuxTypes.String(self._io, self, self._root) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_page_name(self): if hasattr(self, '_m_has_field_page_name'): return self._m_has_field_page_name self._m_has_field_page_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_page_name', None) class ConfigAiOrderServantSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) class IrodoriCardNumerical(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_card_numerical_modification_type: self.card_numerical_modification_type = Output.EnumIrodoriChessCardNumericalModificationType(self._io, self, self._root) if self.has_field_card_numerical_modification_mode: self.card_numerical_modification_mode = Output.EnumIrodoriChessCardNumericalModificationMode(self._io, self, self._root) if self.has_field_card_numerical_modification_value: self.card_numerical_modification_value = self._io.read_f4le() @property def has_field_card_numerical_modification_type(self): if hasattr(self, '_m_has_field_card_numerical_modification_type'): return self._m_has_field_card_numerical_modification_type self._m_has_field_card_numerical_modification_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_type', None) @property def has_field_card_numerical_modification_mode(self): if hasattr(self, '_m_has_field_card_numerical_modification_mode'): return self._m_has_field_card_numerical_modification_mode self._m_has_field_card_numerical_modification_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_mode', None) @property def has_field_card_numerical_modification_value(self): if hasattr(self, '_m_has_field_card_numerical_modification_value'): return self._m_has_field_card_numerical_modification_value self._m_has_field_card_numerical_modification_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_value', None) class TalkRoleEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumTalkRoleType(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_id', None) class DictOfAuxTypesStringConfigPerfStringKeyItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfStringKeyItemOverrideInfo(self._io, self, self._root)) class RandomQuestTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_main_id: self.main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_elem_list: self.elem_list = Output.ArrayOfRandomQuestElemLengthS(self._io, self, self._root) @property def has_field_main_id(self): if hasattr(self, '_m_has_field_main_id'): return self._m_has_field_main_id self._m_has_field_main_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_main_id', None) @property def has_field_elem_list(self): if hasattr(self, '_m_has_field_elem_list'): return self._m_has_field_elem_list self._m_has_field_elem_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_elem_list', None) class StateAudioEventUsageComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMichiaeInteractTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBornByActionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_point_type: self.action_point_type = Output.EnumActionPointType(self._io, self, self._root) if self.has_field_select_type: self.select_type = Output.DispConfigActionPointSelectType(self._io, self, self._root) @property def has_field_action_point_type(self): if hasattr(self, '_m_has_field_action_point_type'): return self._m_has_field_action_point_type self._m_has_field_action_point_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_point_type', None) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def has_field_select_type(self): if hasattr(self, '_m_has_field_select_type'): return self._m_has_field_select_type self._m_has_field_select_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_select_type', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class VehicleSkillDepotExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_id_list: self.skill_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_skill_id_list(self): if hasattr(self, '_m_has_field_skill_id_list'): return self._m_has_field_skill_id_list self._m_has_field_skill_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_id_list', None) class EnumHuntingMonsterCreatePosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingMonsterCreatePosType, self.data.value) return getattr(self, '_m_value', None) class ConfigNpcTalkScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talks: self.talks = Output.ArrayOfConfigTalkSchemeLengthU(self._io, self, self._root) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_npc_id', None) @property def has_field_talks(self): if hasattr(self, '_m_has_field_talks'): return self._m_has_field_talks self._m_has_field_talks = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_talks', None) class SectrSector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_layer_groups: self.layer_groups = Output.ArrayOfSectrLayerGroupLengthU(self._io, self, self._root) if self.has_field_sector_name_hash: self.sector_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumSectrSectorType(self._io, self, self._root) if self.has_field_width_index: self.width_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_height_index: self.height_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_distance_to_change: self.distance_to_change = self._io.read_f4le() if self.has_field_center_pos: self.center_pos = Output.Vector(self._io, self, self._root) @property def has_field_distance_to_change(self): if hasattr(self, '_m_has_field_distance_to_change'): return self._m_has_field_distance_to_change self._m_has_field_distance_to_change = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_distance_to_change', None) @property def has_field_sector_name_hash(self): if hasattr(self, '_m_has_field_sector_name_hash'): return self._m_has_field_sector_name_hash self._m_has_field_sector_name_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sector_name_hash', None) @property def has_field_center_pos(self): if hasattr(self, '_m_has_field_center_pos'): return self._m_has_field_center_pos self._m_has_field_center_pos = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_center_pos', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_height_index(self): if hasattr(self, '_m_has_field_height_index'): return self._m_has_field_height_index self._m_has_field_height_index = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_height_index', None) @property def has_field_layer_groups(self): if hasattr(self, '_m_has_field_layer_groups'): return self._m_has_field_layer_groups self._m_has_field_layer_groups = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_layer_groups', None) @property def has_field_width_index(self): if hasattr(self, '_m_has_field_width_index'): return self._m_has_field_width_index self._m_has_field_width_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_width_index', None) class DieTypeTipsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_die_type: self.die_type = Output.EnumPlayerDieType(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tips: self.tips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_die_type(self): if hasattr(self, '_m_has_field_die_type'): return self._m_has_field_die_type self._m_has_field_die_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_die_type', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_tips(self): if hasattr(self, '_m_has_field_tips'): return self._m_has_field_tips self._m_has_field_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tips', None) class DispConfigGadgetUiBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigGadgetUiBase(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetUiExtraItem(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigGadgetUi(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DictOfEnumInputActionTypeDispConfigBaseInputAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumInputActionTypeDispConfigBaseInputAction(self._io, self, self._root)) class EnumServerMessageShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ServerMessageShowType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigBladeElementFx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigBladeElementFx(self._io, self, self._root)) class SalvageTypeDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumSalvagePlayType(self._io, self, self._root) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_play_type', None) class GroupTagExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SensitiveWordConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionByTeamStatusMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_wait_time: self.wait_time = self._io.read_f4le() if self.has_field_wait_for_bigteam: self.wait_for_bigteam = self._io.read_u1() if self.has_field_run_post_recover: self.run_post_recover = self._io.read_u1() @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_wait_time(self): if hasattr(self, '_m_has_field_wait_time'): return self._m_has_field_wait_time self._m_has_field_wait_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_wait_time', None) @property def has_field_run_post_recover(self): if hasattr(self, '_m_has_field_run_post_recover'): return self._m_has_field_run_post_recover self._m_has_field_run_post_recover = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_run_post_recover', None) @property def has_field_wait_for_bigteam(self): if hasattr(self, '_m_has_field_wait_for_bigteam'): return self._m_has_field_wait_for_bigteam self._m_has_field_wait_for_bigteam = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_wait_for_bigteam', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ReunionWatcherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_watcher_group_id: self.watcher_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activate_level_range: self.activate_level_range = AuxTypes.String(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_unlock_day: self.reward_unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_reward_unlock_day(self): if hasattr(self, '_m_has_field_reward_unlock_day'): return self._m_has_field_reward_unlock_day self._m_has_field_reward_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_unlock_day', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_watcher_group_id(self): if hasattr(self, '_m_has_field_watcher_group_id'): return self._m_has_field_watcher_group_id self._m_has_field_watcher_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_watcher_group_id', None) @property def has_field_activate_level_range(self): if hasattr(self, '_m_has_field_activate_level_range'): return self._m_has_field_activate_level_range self._m_has_field_activate_level_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activate_level_range', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class FleurFairDungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDebuffResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_immune_states: self.immune_states = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) if self.has_field_resistance_ratio: self.resistance_ratio = self._io.read_f4le() if self.has_field_duration_ratio: self.duration_ratio = self._io.read_f4le() @property def has_field_immune_states(self): if hasattr(self, '_m_has_field_immune_states'): return self._m_has_field_immune_states self._m_has_field_immune_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_immune_states', None) @property def has_field_resistance_ratio(self): if hasattr(self, '_m_has_field_resistance_ratio'): return self._m_has_field_resistance_ratio self._m_has_field_resistance_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_resistance_ratio', None) @property def has_field_duration_ratio(self): if hasattr(self, '_m_has_field_duration_ratio'): return self._m_has_field_duration_ratio self._m_has_field_duration_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration_ratio', None) class EnumUgcRayTriggerDirectionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UgcRayTriggerDirectionType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumGadgetUiItemShowCondTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumGadgetUiItemShowCondType(self._io, self, self._root)) class ArrayOfRewardItemConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RewardItemConfig(self._io, self, self._root)) class ConfigGadgetUi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetUiBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_always_interactive: self.always_interactive = self._io.read_u1() if self.has_field_can_interact_in_combat: self.can_interact_in_combat = self._io.read_u1() if self.has_field_can_only_interact_in_stand_still: self.can_only_interact_in_stand_still = self._io.read_u1() if self.has_field_open_reward_id: self.open_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_ui_extra_items: self.gadget_ui_extra_items = Output.ArrayOfConfigGadgetUiExtraItemLengthU(self._io, self, self._root) @property def post_gadget_action_params(self): if hasattr(self, '_m_post_gadget_action_params'): return self._m_post_gadget_action_params self._m_post_gadget_action_params = self.base.post_gadget_action_params return getattr(self, '_m_post_gadget_action_params', None) @property def has_field_can_only_interact_in_stand_still(self): if hasattr(self, '_m_has_field_can_only_interact_in_stand_still'): return self._m_has_field_can_only_interact_in_stand_still self._m_has_field_can_only_interact_in_stand_still = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_can_only_interact_in_stand_still', None) @property def has_field_open_reward_id(self): if hasattr(self, '_m_has_field_open_reward_id'): return self._m_has_field_open_reward_id self._m_has_field_open_reward_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_open_reward_id', None) @property def on_touch(self): if hasattr(self, '_m_on_touch'): return self._m_on_touch self._m_on_touch = self.base.on_touch return getattr(self, '_m_on_touch', None) @property def has_field_can_interact_in_combat(self): if hasattr(self, '_m_has_field_can_interact_in_combat'): return self._m_has_field_can_interact_in_combat self._m_has_field_can_interact_in_combat = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_can_interact_in_combat', None) @property def confirm_dialog_title(self): if hasattr(self, '_m_confirm_dialog_title'): return self._m_confirm_dialog_title self._m_confirm_dialog_title = self.base.confirm_dialog_title return getattr(self, '_m_confirm_dialog_title', None) @property def has_field_always_interactive(self): if hasattr(self, '_m_has_field_always_interactive'): return self._m_has_field_always_interactive self._m_has_field_always_interactive = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_always_interactive', None) @property def touch_params(self): if hasattr(self, '_m_touch_params'): return self._m_touch_params self._m_touch_params = self.base.touch_params return getattr(self, '_m_touch_params', None) @property def item_type(self): if hasattr(self, '_m_item_type'): return self._m_item_type self._m_item_type = self.base.item_type return getattr(self, '_m_item_type', None) @property def confirm_dialog_content(self): if hasattr(self, '_m_confirm_dialog_content'): return self._m_confirm_dialog_content self._m_confirm_dialog_content = self.base.confirm_dialog_content return getattr(self, '_m_confirm_dialog_content', None) @property def gadget_ui_btn_cfg_path(self): if hasattr(self, '_m_gadget_ui_btn_cfg_path'): return self._m_gadget_ui_btn_cfg_path self._m_gadget_ui_btn_cfg_path = self.base.gadget_ui_btn_cfg_path return getattr(self, '_m_gadget_ui_btn_cfg_path', None) @property def has_field_gadget_ui_extra_items(self): if hasattr(self, '_m_has_field_gadget_ui_extra_items'): return self._m_has_field_gadget_ui_extra_items self._m_has_field_gadget_ui_extra_items = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_gadget_ui_extra_items', None) @property def need_dialog_confirm(self): if hasattr(self, '_m_need_dialog_confirm'): return self._m_need_dialog_confirm self._m_need_dialog_confirm = self.base.need_dialog_confirm return getattr(self, '_m_need_dialog_confirm', None) @property def group_name(self): if hasattr(self, '_m_group_name'): return self._m_group_name self._m_group_name = self.base.group_name return getattr(self, '_m_group_name', None) @property def ui_name(self): if hasattr(self, '_m_ui_name'): return self._m_ui_name self._m_ui_name = self.base.ui_name return getattr(self, '_m_ui_name', None) @property def icon(self): if hasattr(self, '_m_icon'): return self._m_icon self._m_icon = self.base.icon return getattr(self, '_m_icon', None) @property def show_comb_type(self): if hasattr(self, '_m_show_comb_type'): return self._m_show_comb_type self._m_show_comb_type = self.base.show_comb_type return getattr(self, '_m_show_comb_type', None) @property def show_cond_types(self): if hasattr(self, '_m_show_cond_types'): return self._m_show_cond_types self._m_show_cond_types = self.base.show_cond_types return getattr(self, '_m_show_cond_types', None) class ConfigAvatarFocus(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_hor_move_speed: self.camera_hor_move_speed = self._io.read_f4le() if self.has_field_camera_ver_move_speed: self.camera_ver_move_speed = self._io.read_f4le() if self.has_field_camera_hor_sticky_ratio: self.camera_hor_sticky_ratio = self._io.read_f4le() if self.has_field_camera_ver_sticky_ratio: self.camera_ver_sticky_ratio = self._io.read_f4le() if self.has_field_auto_focus_hor_speed: self.auto_focus_hor_speed = self._io.read_f4le() if self.has_field_auto_focus_ver_speed: self.auto_focus_ver_speed = self._io.read_f4le() if self.has_field_auto_focus_range_coef: self.auto_focus_range_coef = self._io.read_f4le() if self.has_field_gyro_hor_move_speed: self.gyro_hor_move_speed = self._io.read_f4le() if self.has_field_gyro_ver_move_speed: self.gyro_ver_move_speed = self._io.read_f4le() @property def has_field_camera_ver_move_speed(self): if hasattr(self, '_m_has_field_camera_ver_move_speed'): return self._m_has_field_camera_ver_move_speed self._m_has_field_camera_ver_move_speed = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_camera_ver_move_speed', None) @property def has_field_camera_hor_sticky_ratio(self): if hasattr(self, '_m_has_field_camera_hor_sticky_ratio'): return self._m_has_field_camera_hor_sticky_ratio self._m_has_field_camera_hor_sticky_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_camera_hor_sticky_ratio', None) @property def has_field_gyro_ver_move_speed(self): if hasattr(self, '_m_has_field_gyro_ver_move_speed'): return self._m_has_field_gyro_ver_move_speed self._m_has_field_gyro_ver_move_speed = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_gyro_ver_move_speed', None) @property def has_field_camera_ver_sticky_ratio(self): if hasattr(self, '_m_has_field_camera_ver_sticky_ratio'): return self._m_has_field_camera_ver_sticky_ratio self._m_has_field_camera_ver_sticky_ratio = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_camera_ver_sticky_ratio', None) @property def has_field_camera_hor_move_speed(self): if hasattr(self, '_m_has_field_camera_hor_move_speed'): return self._m_has_field_camera_hor_move_speed self._m_has_field_camera_hor_move_speed = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_camera_hor_move_speed', None) @property def has_field_auto_focus_range_coef(self): if hasattr(self, '_m_has_field_auto_focus_range_coef'): return self._m_has_field_auto_focus_range_coef self._m_has_field_auto_focus_range_coef = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_auto_focus_range_coef', None) @property def has_field_auto_focus_ver_speed(self): if hasattr(self, '_m_has_field_auto_focus_ver_speed'): return self._m_has_field_auto_focus_ver_speed self._m_has_field_auto_focus_ver_speed = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_auto_focus_ver_speed', None) @property def has_field_gyro_hor_move_speed(self): if hasattr(self, '_m_has_field_gyro_hor_move_speed'): return self._m_has_field_gyro_hor_move_speed self._m_has_field_gyro_hor_move_speed = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_gyro_hor_move_speed', None) @property def has_field_auto_focus_hor_speed(self): if hasattr(self, '_m_has_field_auto_focus_hor_speed'): return self._m_has_field_auto_focus_hor_speed self._m_has_field_auto_focus_hor_speed = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_auto_focus_hor_speed', None) class EnumBrickType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BrickType, self.data.value) return getattr(self, '_m_value', None) class ConfigMultiBulletPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_multi_bullet_config: self.multi_bullet_config = Output.DispConfigMultiBullet(self._io, self, self._root) @property def collider_check_on_init(self): if hasattr(self, '_m_collider_check_on_init'): return self._m_collider_check_on_init self._m_collider_check_on_init = self.base.collider_check_on_init return getattr(self, '_m_collider_check_on_init', None) @property def has_field_multi_bullet_config(self): if hasattr(self, '_m_has_field_multi_bullet_config'): return self._m_has_field_multi_bullet_config self._m_has_field_multi_bullet_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_multi_bullet_config', None) @property def trigger_life_over_actions(self): if hasattr(self, '_m_trigger_life_over_actions'): return self._m_trigger_life_over_actions self._m_trigger_life_over_actions = self.base.trigger_life_over_actions return getattr(self, '_m_trigger_life_over_actions', None) @property def fire_ai_sound_event(self): if hasattr(self, '_m_fire_ai_sound_event'): return self._m_fire_ai_sound_event self._m_fire_ai_sound_event = self.base.fire_ai_sound_event return getattr(self, '_m_fire_ai_sound_event', None) @property def trigger_actions(self): if hasattr(self, '_m_trigger_actions'): return self._m_trigger_actions self._m_trigger_actions = self.base.trigger_actions return getattr(self, '_m_trigger_actions', None) @property def die_delay_time(self): if hasattr(self, '_m_die_delay_time'): return self._m_die_delay_time self._m_die_delay_time = self.base.die_delay_time return getattr(self, '_m_die_delay_time', None) @property def enable_collision_delay(self): if hasattr(self, '_m_enable_collision_delay'): return self._m_enable_collision_delay self._m_enable_collision_delay = self.base.enable_collision_delay return getattr(self, '_m_enable_collision_delay', None) @property def collision(self): if hasattr(self, '_m_collision'): return self._m_collision self._m_collision = self.base.collision return getattr(self, '_m_collision', None) @property def kill_by_other(self): if hasattr(self, '_m_kill_by_other'): return self._m_kill_by_other self._m_kill_by_other = self.base.kill_by_other return getattr(self, '_m_kill_by_other', None) @property def max_auto_kill_dist(self): if hasattr(self, '_m_max_auto_kill_dist'): return self._m_max_auto_kill_dist self._m_max_auto_kill_dist = self.base.max_auto_kill_dist return getattr(self, '_m_max_auto_kill_dist', None) class RogueGadgetRotConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigSchedulerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigSchedulerType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringEnumTokenForceEnqueueReason(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringEnumTokenForceEnqueueReason(self._io, self, self._root)) class ConfigSummonTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_summon_tag: self.summon_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_copy_owner_threat_list: self.copy_owner_threat_list = self._io.read_u1() if self.has_field_use_owner_defend_area: self.use_owner_defend_area = self._io.read_u1() @property def has_field_summon_tag(self): if hasattr(self, '_m_has_field_summon_tag'): return self._m_has_field_summon_tag self._m_has_field_summon_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_summon_tag', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_num', None) @property def has_field_use_owner_defend_area(self): if hasattr(self, '_m_has_field_use_owner_defend_area'): return self._m_has_field_use_owner_defend_area self._m_has_field_use_owner_defend_area = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_owner_defend_area', None) @property def has_field_copy_owner_threat_list(self): if hasattr(self, '_m_has_field_copy_owner_threat_list'): return self._m_has_field_copy_owner_threat_list self._m_has_field_copy_owner_threat_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_copy_owner_threat_list', None) class ConfigCustomGadgetNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_custom_gadget_type: self.custom_gadget_type = Output.EnumCustomGadgetType(self._io, self, self._root) if self.has_field_camera_settings: self.camera_settings = Output.CustomGadgetCameraSettings(self._io, self, self._root) if self.has_field_slot_map: self.slot_map = Output.DictOfAuxTypesStringCustomGadgetNodeSlot(self._io, self, self._root) @property def has_field_custom_gadget_type(self): if hasattr(self, '_m_has_field_custom_gadget_type'): return self._m_has_field_custom_gadget_type self._m_has_field_custom_gadget_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_gadget_type', None) @property def has_field_camera_settings(self): if hasattr(self, '_m_has_field_camera_settings'): return self._m_has_field_camera_settings self._m_has_field_camera_settings = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camera_settings', None) @property def has_field_slot_map(self): if hasattr(self, '_m_has_field_slot_map'): return self._m_has_field_slot_map self._m_has_field_slot_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_slot_map', None) class ByHitStrikeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_strike_type: self.strike_type = Output.EnumStrikeType(self._io, self, self._root) @property def has_field_strike_type(self): if hasattr(self, '_m_has_field_strike_type'): return self._m_has_field_strike_type self._m_has_field_strike_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_strike_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class GroupIoTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DungeonEntrySatisfiedConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPublicAiSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPublicAiSkillCd(self._io, self, self._root)) class DictOfEnumPerfRatingCategoryArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPerfRatingCategoryArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root)) class EnumConfigSchedulePlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigSchedulePlatform, self.data.value) return getattr(self, '_m_value', None) class EnumGachaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GachaType, self.data.value) return getattr(self, '_m_value', None) class EnumBoredActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BoredActionType, self.data.value) return getattr(self, '_m_value', None) class TemplateReminderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OraionokamiDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_chain_id: self.gadget_chain_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_chain_level: self.gadget_chain_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_buff_id: self.server_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_id_list: self.desc_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_desc_title: self.desc_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_content: self.desc_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_skill: self.desc_skill = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_level: self.type_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_server_buff_id(self): if hasattr(self, '_m_has_field_server_buff_id'): return self._m_has_field_server_buff_id self._m_has_field_server_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_server_buff_id', None) @property def has_field_desc_skill(self): if hasattr(self, '_m_has_field_desc_skill'): return self._m_has_field_desc_skill self._m_has_field_desc_skill = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc_skill', None) @property def has_field_gadget_chain_level(self): if hasattr(self, '_m_has_field_gadget_chain_level'): return self._m_has_field_gadget_chain_level self._m_has_field_gadget_chain_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gadget_chain_level', None) @property def has_field_desc_title(self): if hasattr(self, '_m_has_field_desc_title'): return self._m_has_field_desc_title self._m_has_field_desc_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc_title', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_desc_id_list(self): if hasattr(self, '_m_has_field_desc_id_list'): return self._m_has_field_desc_id_list self._m_has_field_desc_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc_id_list', None) @property def has_field_gadget_chain_id(self): if hasattr(self, '_m_has_field_gadget_chain_id'): return self._m_has_field_gadget_chain_id self._m_has_field_gadget_chain_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_chain_id', None) @property def has_field_desc_content(self): if hasattr(self, '_m_has_field_desc_content'): return self._m_has_field_desc_content self._m_has_field_desc_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc_content', None) @property def has_field_type_level(self): if hasattr(self, '_m_has_field_type_level'): return self._m_has_field_type_level self._m_has_field_type_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_type_level', None) class ArrayOfArrayOfAuxTypesStringLengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root)) class ReputationEntranceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByElementTriggerEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_forceby_origin_owner: self.forceby_origin_owner = self._io.read_u1() @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_types', None) @property def has_field_forceby_origin_owner(self): if hasattr(self, '_m_has_field_forceby_origin_owner'): return self._m_has_field_forceby_origin_owner self._m_has_field_forceby_origin_owner = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_forceby_origin_owner', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class IndicatorConditionGadgetState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_state: self.from_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_to_state: self.to_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_from_state(self): if hasattr(self, '_m_has_field_from_state'): return self._m_has_field_from_state self._m_has_field_from_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_state', None) @property def has_field_to_state(self): if hasattr(self, '_m_has_field_to_state'): return self._m_has_field_to_state self._m_has_field_to_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_state', None) class ArrayOfDispContextConditionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispContextCondition(self._io, self, self._root)) class EnumDailyTaskType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DailyTaskType, self.data.value) return getattr(self, '_m_value', None) class TowerRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigTdPlayTowerData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tower_type: self.tower_type = Output.EnumTdPlayTowerType(self._io, self, self._root) if self.has_field_damage_per_level: self.damage_per_level = self._io.read_f4le() if self.has_field_elem_mastery_per_level: self.elem_mastery_per_level = self._io.read_f4le() if self.has_field_elem_mastery_per_per_stack: self.elem_mastery_per_per_stack = self._io.read_f4le() if self.has_field_damage_a_per_stack: self.damage_a_per_stack = self._io.read_f4le() if self.has_field_damage_b_per_stack: self.damage_b_per_stack = self._io.read_f4le() if self.has_field_attack_speed_a: self.attack_speed_a = self._io.read_f4le() if self.has_field_attack_speed_b: self.attack_speed_b = self._io.read_f4le() if self.has_field_attack_range_a: self.attack_range_a = self._io.read_f4le() if self.has_field_attack_range_b: self.attack_range_b = self._io.read_f4le() @property def has_field_damage_per_level(self): if hasattr(self, '_m_has_field_damage_per_level'): return self._m_has_field_damage_per_level self._m_has_field_damage_per_level = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_damage_per_level', None) @property def has_field_attack_range_b(self): if hasattr(self, '_m_has_field_attack_range_b'): return self._m_has_field_attack_range_b self._m_has_field_attack_range_b = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_attack_range_b', None) @property def has_field_attack_speed_a(self): if hasattr(self, '_m_has_field_attack_speed_a'): return self._m_has_field_attack_speed_a self._m_has_field_attack_speed_a = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_attack_speed_a', None) @property def has_field_attack_range_a(self): if hasattr(self, '_m_has_field_attack_range_a'): return self._m_has_field_attack_range_a self._m_has_field_attack_range_a = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_attack_range_a', None) @property def has_field_damage_b_per_stack(self): if hasattr(self, '_m_has_field_damage_b_per_stack'): return self._m_has_field_damage_b_per_stack self._m_has_field_damage_b_per_stack = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_damage_b_per_stack', None) @property def has_field_elem_mastery_per_level(self): if hasattr(self, '_m_has_field_elem_mastery_per_level'): return self._m_has_field_elem_mastery_per_level self._m_has_field_elem_mastery_per_level = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_elem_mastery_per_level', None) @property def has_field_damage_a_per_stack(self): if hasattr(self, '_m_has_field_damage_a_per_stack'): return self._m_has_field_damage_a_per_stack self._m_has_field_damage_a_per_stack = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_damage_a_per_stack', None) @property def has_field_elem_mastery_per_per_stack(self): if hasattr(self, '_m_has_field_elem_mastery_per_per_stack'): return self._m_has_field_elem_mastery_per_per_stack self._m_has_field_elem_mastery_per_per_stack = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_elem_mastery_per_per_stack', None) @property def has_field_tower_type(self): if hasattr(self, '_m_has_field_tower_type'): return self._m_has_field_tower_type self._m_has_field_tower_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_tower_type', None) @property def has_field_attack_speed_b(self): if hasattr(self, '_m_has_field_attack_speed_b'): return self._m_has_field_attack_speed_b self._m_has_field_attack_speed_b = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_attack_speed_b', None) class DictOfAuxTypesVlqBase128LeUDispConfigCoopBaseNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUDispConfigCoopBaseNode(self._io, self, self._root)) class Ps5groupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_export_version: self.export_version = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_export_version(self): if hasattr(self, '_m_has_field_export_version'): return self._m_has_field_export_version self._m_has_field_export_version = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_export_version', None) class ConfigAiProfilingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_lod_strategy: self.lod_strategy = Output.EnumAiLodStrategyType(self._io, self, self._root) if self.has_field_static_poses: self.static_poses = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_move_culling_level: self.move_culling_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_lod_strategy(self): if hasattr(self, '_m_has_field_lod_strategy'): return self._m_has_field_lod_strategy self._m_has_field_lod_strategy = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lod_strategy', None) @property def has_field_static_poses(self): if hasattr(self, '_m_has_field_static_poses'): return self._m_has_field_static_poses self._m_has_field_static_poses = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_static_poses', None) @property def has_field_move_culling_level(self): if hasattr(self, '_m_has_field_move_culling_level'): return self._m_has_field_move_culling_level self._m_has_field_move_culling_level = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_move_culling_level', None) class ArrayOfConfigCrowdQuestRestrictionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdQuestRestriction(self._io, self, self._root)) class ConfigAudioStageProgressEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_progress: self.progress = self._io.read_f4le() if self.has_field_events: self.events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_progress', None) @property def has_field_events(self): if hasattr(self, '_m_has_field_events'): return self._m_has_field_events self._m_has_field_events = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_events', None) class EnumBlossomRefreshCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlossomRefreshCondType, self.data.value) return getattr(self, '_m_value', None) class CheckGround(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_raycast_up_height: self.raycast_up_height = self._io.read_f4le() if self.has_field_raycast_down_height: self.raycast_down_height = self._io.read_f4le() if self.has_field_stick_to_ground_if_valid: self.stick_to_ground_if_valid = self._io.read_u1() if self.has_field_dont_create_if_invalid: self.dont_create_if_invalid = self._io.read_u1() @property def has_field_stick_to_ground_if_valid(self): if hasattr(self, '_m_has_field_stick_to_ground_if_valid'): return self._m_has_field_stick_to_ground_if_valid self._m_has_field_stick_to_ground_if_valid = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_stick_to_ground_if_valid', None) @property def has_field_dont_create_if_invalid(self): if hasattr(self, '_m_has_field_dont_create_if_invalid'): return self._m_has_field_dont_create_if_invalid self._m_has_field_dont_create_if_invalid = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_dont_create_if_invalid', None) @property def has_field_raycast_up_height(self): if hasattr(self, '_m_has_field_raycast_up_height'): return self._m_has_field_raycast_up_height self._m_has_field_raycast_up_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_raycast_up_height', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_raycast_down_height(self): if hasattr(self, '_m_has_field_raycast_down_height'): return self._m_has_field_raycast_down_height self._m_has_field_raycast_down_height = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_raycast_down_height', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiCombatFollowMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiCombatFollowMoveData(self._io, self, self._root) class ConfigMonsterStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigNormalStateIdInfo(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable_bone_follow_move: self.enable_bone_follow_move = self._io.read_u1() if self.has_field_can_steer: self.can_steer = self._io.read_u1() if self.has_field_auto_steer: self.auto_steer = self._io.read_u1() if self.has_field_follow_anim_rotation: self.follow_anim_rotation = self._io.read_u1() if self.has_field_gravity_adjust_scale: self.gravity_adjust_scale = self._io.read_f4le() if self.has_field_force_set_air_move: self.force_set_air_move = self._io.read_u1() if self.has_field_remote_force_close_air_move: self.remote_force_close_air_move = self._io.read_u1() if self.has_field_remote_force_use_animator_vel: self.remote_force_use_animator_vel = self._io.read_u1() if self.has_field_blend_move: self.blend_move = Output.EnumBlendMoveType(self._io, self, self._root) if self.has_field_air_move_follow_animation: self.air_move_follow_animation = self._io.read_u1() @property def set_animator_float(self): if hasattr(self, '_m_set_animator_float'): return self._m_set_animator_float self._m_set_animator_float = self.base.set_animator_float return getattr(self, '_m_set_animator_float', None) @property def can_do_skill(self): if hasattr(self, '_m_can_do_skill'): return self._m_can_do_skill self._m_can_do_skill = self.base.can_do_skill return getattr(self, '_m_can_do_skill', None) @property def enable_ccd(self): if hasattr(self, '_m_enable_ccd'): return self._m_enable_ccd self._m_enable_ccd = self.base.enable_ccd return getattr(self, '_m_enable_ccd', None) @property def culling_model_always_animate(self): if hasattr(self, '_m_culling_model_always_animate'): return self._m_culling_model_always_animate self._m_culling_model_always_animate = self.base.culling_model_always_animate return getattr(self, '_m_culling_model_always_animate', None) @property def has_field_auto_steer(self): if hasattr(self, '_m_has_field_auto_steer'): return self._m_has_field_auto_steer self._m_has_field_auto_steer = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_auto_steer', None) @property def add_endure(self): if hasattr(self, '_m_add_endure'): return self._m_add_endure self._m_add_endure = self.base.add_endure return getattr(self, '_m_add_endure', None) @property def reset_animator_trigger_on_exit(self): if hasattr(self, '_m_reset_animator_trigger_on_exit'): return self._m_reset_animator_trigger_on_exit self._m_reset_animator_trigger_on_exit = self.base.reset_animator_trigger_on_exit return getattr(self, '_m_reset_animator_trigger_on_exit', None) @property def mass_ratio(self): if hasattr(self, '_m_mass_ratio'): return self._m_mass_ratio self._m_mass_ratio = self.base.mass_ratio return getattr(self, '_m_mass_ratio', None) @property def has_field_remote_force_use_animator_vel(self): if hasattr(self, '_m_has_field_remote_force_use_animator_vel'): return self._m_has_field_remote_force_use_animator_vel self._m_has_field_remote_force_use_animator_vel = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_remote_force_use_animator_vel', None) @property def animator_states(self): if hasattr(self, '_m_animator_states'): return self._m_animator_states self._m_animator_states = self.base.animator_states return getattr(self, '_m_animator_states', None) @property def has_field_can_steer(self): if hasattr(self, '_m_has_field_can_steer'): return self._m_has_field_can_steer self._m_has_field_can_steer = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_can_steer', None) @property def has_field_gravity_adjust_scale(self): if hasattr(self, '_m_has_field_gravity_adjust_scale'): return self._m_has_field_gravity_adjust_scale self._m_has_field_gravity_adjust_scale = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_gravity_adjust_scale', None) @property def combat_move_on_water(self): if hasattr(self, '_m_combat_move_on_water'): return self._m_combat_move_on_water self._m_combat_move_on_water = self.base.combat_move_on_water return getattr(self, '_m_combat_move_on_water', None) @property def set_animator_boolean(self): if hasattr(self, '_m_set_animator_boolean'): return self._m_set_animator_boolean self._m_set_animator_boolean = self.base.set_animator_boolean return getattr(self, '_m_set_animator_boolean', None) @property def has_field_air_move_follow_animation(self): if hasattr(self, '_m_has_field_air_move_follow_animation'): return self._m_has_field_air_move_follow_animation self._m_has_field_air_move_follow_animation = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_air_move_follow_animation', None) @property def handle_animator_state_immediately(self): if hasattr(self, '_m_handle_animator_state_immediately'): return self._m_handle_animator_state_immediately self._m_handle_animator_state_immediately = self.base.handle_animator_state_immediately return getattr(self, '_m_handle_animator_state_immediately', None) @property def has_field_follow_anim_rotation(self): if hasattr(self, '_m_has_field_follow_anim_rotation'): return self._m_has_field_follow_anim_rotation self._m_has_field_follow_anim_rotation = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_follow_anim_rotation', None) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def can_do_skill_start(self): if hasattr(self, '_m_can_do_skill_start'): return self._m_can_do_skill_start self._m_can_do_skill_start = self.base.can_do_skill_start return getattr(self, '_m_can_do_skill_start', None) @property def has_field_enable_bone_follow_move(self): if hasattr(self, '_m_has_field_enable_bone_follow_move'): return self._m_has_field_enable_bone_follow_move self._m_has_field_enable_bone_follow_move = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_enable_bone_follow_move', None) @property def can_sync_move(self): if hasattr(self, '_m_can_sync_move'): return self._m_can_sync_move self._m_can_sync_move = self.base.can_sync_move return getattr(self, '_m_can_sync_move', None) @property def reset_animator_trigger_on_enter(self): if hasattr(self, '_m_reset_animator_trigger_on_enter'): return self._m_reset_animator_trigger_on_enter self._m_reset_animator_trigger_on_enter = self.base.reset_animator_trigger_on_enter return getattr(self, '_m_reset_animator_trigger_on_enter', None) @property def has_field_remote_force_close_air_move(self): if hasattr(self, '_m_has_field_remote_force_close_air_move'): return self._m_has_field_remote_force_close_air_move self._m_has_field_remote_force_close_air_move = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_remote_force_close_air_move', None) @property def can_do_skill_end(self): if hasattr(self, '_m_can_do_skill_end'): return self._m_can_do_skill_end self._m_can_do_skill_end = self.base.can_do_skill_end return getattr(self, '_m_can_do_skill_end', None) @property def has_field_blend_move(self): if hasattr(self, '_m_has_field_blend_move'): return self._m_has_field_blend_move self._m_has_field_blend_move = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_blend_move', None) @property def move_type(self): if hasattr(self, '_m_move_type'): return self._m_move_type self._m_move_type = self.base.move_type return getattr(self, '_m_move_type', None) @property def need_face_to_anim_param(self): if hasattr(self, '_m_need_face_to_anim_param'): return self._m_need_face_to_anim_param self._m_need_face_to_anim_param = self.base.need_face_to_anim_param return getattr(self, '_m_need_face_to_anim_param', None) @property def has_field_force_set_air_move(self): if hasattr(self, '_m_has_field_force_set_air_move'): return self._m_has_field_force_set_air_move self._m_has_field_force_set_air_move = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_force_set_air_move', None) @property def enable_rag_doll(self): if hasattr(self, '_m_enable_rag_doll'): return self._m_enable_rag_doll self._m_enable_rag_doll = self.base.enable_rag_doll return getattr(self, '_m_enable_rag_doll', None) class DictOfAuxTypesVlqBase128LeUAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUAuxTypesString(self._io, self, self._root)) class CookRecipeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialAvatarDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_id: self.trial_avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_trial_avatar_id(self): if hasattr(self, '_m_has_field_trial_avatar_id'): return self._m_has_field_trial_avatar_id self._m_has_field_trial_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_trial_avatar_id', None) class ConfigGuideCheckTaskFinishCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_task_id', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class DictOfAuxTypesStringConfigPerfBoolItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfBoolItemOverrideInfo(self._io, self, self._root)) class ConfigBattleFervorUpdateTriggerByStateIdChanged(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumBattleFervorStateIdTriggerType(self._io, self, self._root) if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_cd: self.cd = self._io.read_f4le() @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class KvpOfDictAuxTypesStringConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigWwiseString(self._io, self, self._root) class EventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNarratorDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class ConfigAudioPositionedEventOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioPositionedOp(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def positioning(self): if hasattr(self, '_m_positioning'): return self._m_positioning self._m_positioning = self.base.positioning return getattr(self, '_m_positioning', None) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class ArrayOfConfigRecordActorInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRecordActorInfo(self._io, self, self._root)) class DictOfEnumEntityTokenActionTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumEntityTokenActionTypeAuxTypesVlqBase128LeS(self._io, self, self._root)) class WeaponCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weapon_id: self.weapon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() if self.has_field_show_only_unlocked: self.show_only_unlocked = self._io.read_u1() @property def has_field_weapon_id(self): if hasattr(self, '_m_has_field_weapon_id'): return self._m_has_field_weapon_id self._m_has_field_weapon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weapon_id', None) @property def has_field_show_only_unlocked(self): if hasattr(self, '_m_has_field_show_only_unlocked'): return self._m_has_field_show_only_unlocked self._m_has_field_show_only_unlocked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_show_only_unlocked', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class FindHilichurlHiliWeiExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideRatingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_channel_id: self.channel_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_channel_id: self.sub_channel_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_china_server: self.is_china_server = self._io.read_u1() if self.has_field_platform: self.platform = Output.EnumGuidePlatformType(self._io, self, self._root) if self.has_field_url: self.url = AuxTypes.String(self._io, self, self._root) @property def has_field_platform(self): if hasattr(self, '_m_has_field_platform'): return self._m_has_field_platform self._m_has_field_platform = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_platform', None) @property def has_field_url(self): if hasattr(self, '_m_has_field_url'): return self._m_has_field_url self._m_has_field_url = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_url', None) @property def has_field_is_china_server(self): if hasattr(self, '_m_has_field_is_china_server'): return self._m_has_field_is_china_server self._m_has_field_is_china_server = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_china_server', None) @property def has_field_channel_id(self): if hasattr(self, '_m_has_field_channel_id'): return self._m_has_field_channel_id self._m_has_field_channel_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_channel_id', None) @property def has_field_sub_channel_id(self): if hasattr(self, '_m_has_field_sub_channel_id'): return self._m_has_field_sub_channel_id self._m_has_field_sub_channel_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_channel_id', None) class ActivitySummerTimeRaceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_medal_watcher: self.medal_watcher = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_world_coord: self.world_coord = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_medal_point: self.medal_point = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_title: self.level_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_factor: self.time_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gold_factor: self.gold_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_cond_id: self.activity_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boat_point_config_id: self.boat_point_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_point_config_id: self.player_point_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_medal_watcher(self): if hasattr(self, '_m_has_field_medal_watcher'): return self._m_has_field_medal_watcher self._m_has_field_medal_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_medal_watcher', None) @property def has_field_level_title(self): if hasattr(self, '_m_has_field_level_title'): return self._m_has_field_level_title self._m_has_field_level_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_title', None) @property def has_field_activity_cond_id(self): if hasattr(self, '_m_has_field_activity_cond_id'): return self._m_has_field_activity_cond_id self._m_has_field_activity_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_activity_cond_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_gold_factor(self): if hasattr(self, '_m_has_field_gold_factor'): return self._m_has_field_gold_factor self._m_has_field_gold_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_gold_factor', None) @property def has_field_player_point_config_id(self): if hasattr(self, '_m_has_field_player_point_config_id'): return self._m_has_field_player_point_config_id self._m_has_field_player_point_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_player_point_config_id', None) @property def has_field_world_coord(self): if hasattr(self, '_m_has_field_world_coord'): return self._m_has_field_world_coord self._m_has_field_world_coord = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_world_coord', None) @property def has_field_boat_point_config_id(self): if hasattr(self, '_m_has_field_boat_point_config_id'): return self._m_has_field_boat_point_config_id self._m_has_field_boat_point_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_boat_point_config_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_time_factor(self): if hasattr(self, '_m_has_field_time_factor'): return self._m_has_field_time_factor self._m_has_field_time_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_time_factor', None) @property def has_field_medal_point(self): if hasattr(self, '_m_has_field_medal_point'): return self._m_has_field_medal_point self._m_has_field_medal_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_medal_point', None) class QuestSpecialShowConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumQuestSpecialShowType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_tips: self.show_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_show_tips(self): if hasattr(self, '_m_has_field_show_tips'): return self._m_has_field_show_tips self._m_has_field_show_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_show_tips', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param2', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_type', None) class JsonTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetActivityGacha(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetUseAttachAbilityTrigger(self._io, self, self._root) @property def is_team(self): if hasattr(self, '_m_is_team'): return self._m_is_team self._m_is_team = self.base.is_team return getattr(self, '_m_is_team', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def ability_group_name(self): if hasattr(self, '_m_ability_group_name'): return self._m_ability_group_name self._m_ability_group_name = self.base.ability_group_name return getattr(self, '_m_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def trigger_ability_name(self): if hasattr(self, '_m_trigger_ability_name'): return self._m_trigger_ability_name self._m_trigger_ability_name = self.base.trigger_ability_name return getattr(self, '_m_trigger_ability_name', None) class DeliveryQuestConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_parent_quest_id: self.parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delivery_quest_id: self.delivery_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_quest_id: self.start_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_quest_id: self.talk_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_start_quest_id(self): if hasattr(self, '_m_has_field_start_quest_id'): return self._m_has_field_start_quest_id self._m_has_field_start_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_start_quest_id', None) @property def has_field_talk_quest_id(self): if hasattr(self, '_m_has_field_talk_quest_id'): return self._m_has_field_talk_quest_id self._m_has_field_talk_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_talk_quest_id', None) @property def has_field_delivery_quest_id(self): if hasattr(self, '_m_has_field_delivery_quest_id'): return self._m_has_field_delivery_quest_id self._m_has_field_delivery_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_delivery_quest_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_parent_quest_id(self): if hasattr(self, '_m_has_field_parent_quest_id'): return self._m_has_field_parent_quest_id self._m_has_field_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_parent_quest_id', None) class SensitiveWordConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_word: self.word = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_word(self): if hasattr(self, '_m_has_field_word'): return self._m_has_field_word self._m_has_field_word = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_word', None) class ForceAirStateFly(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_active: self.is_active = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_active', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class GuideTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OutputSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_bus: self.bus = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_channel_mask: self.channel_mask = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bus_channel_config_list: self.bus_channel_config_list = Output.ArrayOfBusChannelConfigLengthU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_bus(self): if hasattr(self, '_m_has_field_bus'): return self._m_has_field_bus self._m_has_field_bus = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bus', None) @property def has_field_channel_mask(self): if hasattr(self, '_m_has_field_channel_mask'): return self._m_has_field_channel_mask self._m_has_field_channel_mask = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_channel_mask', None) @property def has_field_bus_channel_config_list(self): if hasattr(self, '_m_has_field_bus_channel_config_list'): return self._m_has_field_bus_channel_config_list self._m_has_field_bus_channel_config_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_bus_channel_config_list', None) class ConfigGuideCheckAimCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumTalentPointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalentPointType, self.data.value) return getattr(self, '_m_value', None) class ActivityChessAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeaponCurveExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MaterialDestroyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CheckHitLayerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_paimon_speed_rtpc_key: self.paimon_speed_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_vehicle_collision_rtpc: self.vehicle_collision_rtpc = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_paimon_speed_rtpc_key(self): if hasattr(self, '_m_has_field_paimon_speed_rtpc_key'): return self._m_has_field_paimon_speed_rtpc_key self._m_has_field_paimon_speed_rtpc_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_paimon_speed_rtpc_key', None) @property def has_field_vehicle_collision_rtpc(self): if hasattr(self, '_m_has_field_vehicle_collision_rtpc'): return self._m_has_field_vehicle_collision_rtpc self._m_has_field_vehicle_collision_rtpc = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_vehicle_collision_rtpc', None) class RoomExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetToyAnchorPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cool_down: self.cool_down = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invalid_scene_ids: self.invalid_scene_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_invalid_scene_ids(self): if hasattr(self, '_m_has_field_invalid_scene_ids'): return self._m_has_field_invalid_scene_ids self._m_has_field_invalid_scene_ids = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_invalid_scene_ids', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_cool_down(self): if hasattr(self, '_m_has_field_cool_down'): return self._m_has_field_cool_down self._m_has_field_cool_down = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cool_down', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class ApplyCrystalModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class OpActivityBonusExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_bonus_id: self.bonus_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_source_type: self.source_type = Output.EnumOpActivityBonusSourceType(self._io, self, self._root) if self.has_field_source_param: self.source_param = AuxTypes.String(self._io, self, self._root) if self.has_field_open_level: self.open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_ratio: self.bonus_ratio = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_text_map_id_list: self.text_map_id_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_track_type: self.track_type = Output.EnumOpActivityTrackType(self._io, self, self._root) if self.has_field_track_para: self.track_para = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_icon_background: self.icon_background = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_foreground: self.icon_foreground = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_source_param(self): if hasattr(self, '_m_has_field_source_param'): return self._m_has_field_source_param self._m_has_field_source_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_source_param', None) @property def has_field_track_para(self): if hasattr(self, '_m_has_field_track_para'): return self._m_has_field_track_para self._m_has_field_track_para = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_track_para', None) @property def has_field_text_map_id_list(self): if hasattr(self, '_m_has_field_text_map_id_list'): return self._m_has_field_text_map_id_list self._m_has_field_text_map_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_text_map_id_list', None) @property def has_field_icon_foreground(self): if hasattr(self, '_m_has_field_icon_foreground'): return self._m_has_field_icon_foreground self._m_has_field_icon_foreground = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_icon_foreground', None) @property def has_field_bonus_id(self): if hasattr(self, '_m_has_field_bonus_id'): return self._m_has_field_bonus_id self._m_has_field_bonus_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_bonus_id', None) @property def has_field_open_level(self): if hasattr(self, '_m_has_field_open_level'): return self._m_has_field_open_level self._m_has_field_open_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_level', None) @property def has_field_bonus_ratio(self): if hasattr(self, '_m_has_field_bonus_ratio'): return self._m_has_field_bonus_ratio self._m_has_field_bonus_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_bonus_ratio', None) @property def has_field_track_type(self): if hasattr(self, '_m_has_field_track_type'): return self._m_has_field_track_type self._m_has_field_track_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_track_type', None) @property def has_field_icon_background(self): if hasattr(self, '_m_has_field_icon_background'): return self._m_has_field_icon_background self._m_has_field_icon_background = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_icon_background', None) @property def has_field_source_type(self): if hasattr(self, '_m_has_field_source_type'): return self._m_has_field_source_type self._m_has_field_source_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_source_type', None) class ConfigCannonField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSpeedupField(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def vehicle_target_fov_duration(self): if hasattr(self, '_m_vehicle_target_fov_duration'): return self._m_vehicle_target_fov_duration self._m_vehicle_target_fov_duration = self.base.vehicle_target_fov_duration return getattr(self, '_m_vehicle_target_fov_duration', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def stop_velocity(self): if hasattr(self, '_m_stop_velocity'): return self._m_stop_velocity self._m_stop_velocity = self.base.stop_velocity return getattr(self, '_m_stop_velocity', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def attenuation(self): if hasattr(self, '_m_attenuation'): return self._m_attenuation self._m_attenuation = self.base.attenuation return getattr(self, '_m_attenuation', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def single_dir(self): if hasattr(self, '_m_single_dir'): return self._m_single_dir self._m_single_dir = self.base.single_dir return getattr(self, '_m_single_dir', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def vehicle_fov_exit_speed(self): if hasattr(self, '_m_vehicle_fov_exit_speed'): return self._m_vehicle_fov_exit_speed self._m_vehicle_fov_exit_speed = self.base.vehicle_fov_exit_speed return getattr(self, '_m_vehicle_fov_exit_speed', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def vehicle_target_fov_priority(self): if hasattr(self, '_m_vehicle_target_fov_priority'): return self._m_vehicle_target_fov_priority self._m_vehicle_target_fov_priority = self.base.vehicle_target_fov_priority return getattr(self, '_m_vehicle_target_fov_priority', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def vehicle_target_fov(self): if hasattr(self, '_m_vehicle_target_fov'): return self._m_vehicle_target_fov self._m_vehicle_target_fov = self.base.vehicle_target_fov return getattr(self, '_m_vehicle_target_fov', None) @property def trigger_vehicle(self): if hasattr(self, '_m_trigger_vehicle'): return self._m_trigger_vehicle self._m_trigger_vehicle = self.base.trigger_vehicle return getattr(self, '_m_trigger_vehicle', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def vehicle_fov_enter_speed(self): if hasattr(self, '_m_vehicle_fov_enter_speed'): return self._m_vehicle_fov_enter_speed self._m_vehicle_fov_enter_speed = self.base.vehicle_fov_enter_speed return getattr(self, '_m_vehicle_fov_enter_speed', None) class EnumActivityGachaRobot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGachaRobot, self.data.value) return getattr(self, '_m_value', None) class ExpeditionPathExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MaskGuideTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFlycloakFashionEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tail: self.tail = AuxTypes.String(self._io, self, self._root) if self.has_field_fly_start: self.fly_start = AuxTypes.String(self._io, self, self._root) if self.has_field_fly_end: self.fly_end = AuxTypes.String(self._io, self, self._root) @property def has_field_tail(self): if hasattr(self, '_m_has_field_tail'): return self._m_has_field_tail self._m_has_field_tail = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tail', None) @property def has_field_fly_start(self): if hasattr(self, '_m_has_field_fly_start'): return self._m_has_field_fly_start self._m_has_field_fly_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fly_start', None) @property def has_field_fly_end(self): if hasattr(self, '_m_has_field_fly_end'): return self._m_has_field_fly_end self._m_has_field_fly_end = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fly_end', None) class EnumExploreEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExploreEventType, self.data.value) return getattr(self, '_m_value', None) class ByHitElementDurability(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element: self.element = Output.EnumElementType(self._io, self, self._root) if self.has_field_durability: self.durability = self._io.read_f4le() if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) if self.has_field_apply_attenuation: self.apply_attenuation = self._io.read_u1() @property def has_field_durability(self): if hasattr(self, '_m_has_field_durability'): return self._m_has_field_durability self._m_has_field_durability = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_durability', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_apply_attenuation(self): if hasattr(self, '_m_has_field_apply_attenuation'): return self._m_has_field_apply_attenuation self._m_has_field_apply_attenuation = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_apply_attenuation', None) @property def has_field_element(self): if hasattr(self, '_m_has_field_element'): return self._m_has_field_element self._m_has_field_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_compare_type', None) class TreeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MatchPunishExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_times: self.times = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_punish_time: self.punish_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_times(self): if hasattr(self, '_m_has_field_times'): return self._m_has_field_times self._m_has_field_times = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_times', None) @property def has_field_punish_time(self): if hasattr(self, '_m_has_field_punish_time'): return self._m_has_field_punish_time self._m_has_field_punish_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_punish_time', None) class MichiaeOfferingDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_new_effect_desc: self.level_new_effect_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_new_effect_desc_args: self.level_new_effect_desc_args = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_acc_effect_desc: self.level_acc_effect_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_acc_effect_desc_args: self.level_acc_effect_desc_args = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_level_new_effect_desc(self): if hasattr(self, '_m_has_field_level_new_effect_desc'): return self._m_has_field_level_new_effect_desc self._m_has_field_level_new_effect_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_new_effect_desc', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_level_acc_effect_desc_args(self): if hasattr(self, '_m_has_field_level_acc_effect_desc_args'): return self._m_has_field_level_acc_effect_desc_args self._m_has_field_level_acc_effect_desc_args = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level_acc_effect_desc_args', None) @property def has_field_level_acc_effect_desc(self): if hasattr(self, '_m_has_field_level_acc_effect_desc'): return self._m_has_field_level_acc_effect_desc self._m_has_field_level_acc_effect_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_acc_effect_desc', None) @property def has_field_level_new_effect_desc_args(self): if hasattr(self, '_m_has_field_level_new_effect_desc_args'): return self._m_has_field_level_new_effect_desc_args self._m_has_field_level_new_effect_desc_args = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_new_effect_desc_args', None) class CreateGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.CreateEntity(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_by_server: self.by_server = self._io.read_u1() @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camp_id', None) @property def owner_is_target(self): if hasattr(self, '_m_owner_is_target'): return self._m_owner_is_target self._m_owner_is_target = self.base.owner_is_target return getattr(self, '_m_owner_is_target', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def sight_group_with_owner(self): if hasattr(self, '_m_sight_group_with_owner'): return self._m_sight_group_with_owner self._m_sight_group_with_owner = self.base.sight_group_with_owner return getattr(self, '_m_sight_group_with_owner', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def life_by_owner_is_alive(self): if hasattr(self, '_m_life_by_owner_is_alive'): return self._m_life_by_owner_is_alive self._m_life_by_owner_is_alive = self.base.life_by_owner_is_alive return getattr(self, '_m_life_by_owner_is_alive', None) @property def life_by_owner_v2(self): if hasattr(self, '_m_life_by_owner_v2'): return self._m_life_by_owner_v2 self._m_life_by_owner_v2 = self.base.life_by_owner_v2 return getattr(self, '_m_life_by_owner_v2', None) @property def has_field_by_server(self): if hasattr(self, '_m_has_field_by_server'): return self._m_has_field_by_server self._m_has_field_by_server = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_by_server', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def is_peer_id_from_player(self): if hasattr(self, '_m_is_peer_id_from_player'): return self._m_is_peer_id_from_player self._m_is_peer_id_from_player = self.base.is_peer_id_from_player return getattr(self, '_m_is_peer_id_from_player', None) @property def dont_kill_self_by_client_prediction(self): if hasattr(self, '_m_dont_kill_self_by_client_prediction'): return self._m_dont_kill_self_by_client_prediction self._m_dont_kill_self_by_client_prediction = self.base.dont_kill_self_by_client_prediction return getattr(self, '_m_dont_kill_self_by_client_prediction', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def prop_owner_is(self): if hasattr(self, '_m_prop_owner_is'): return self._m_prop_owner_is self._m_prop_owner_is = self.base.prop_owner_is return getattr(self, '_m_prop_owner_is', None) @property def owner_is(self): if hasattr(self, '_m_owner_is'): return self._m_owner_is self._m_owner_is = self.base.owner_is return getattr(self, '_m_owner_is', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def check_ground(self): if hasattr(self, '_m_check_ground'): return self._m_check_ground self._m_check_ground = self.base.check_ground return getattr(self, '_m_check_ground', None) class OpenStateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSceneTagCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneTagCondType, self.data.value) return getattr(self, '_m_value', None) class EnumInputDeviceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InputDeviceType, self.data.value) return getattr(self, '_m_value', None) class SkillButtonHoldChargeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_allow_hold_lock_direction: self.allow_hold_lock_direction = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_loop_trigger_id: self.next_loop_trigger_id = AuxTypes.String(self._io, self, self._root) if self.has_field_end_hold_trigger: self.end_hold_trigger = AuxTypes.String(self._io, self, self._root) if self.has_field_before_state_i_ds: self.before_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_before_hold_duration: self.before_hold_duration = self._io.read_f4le() if self.has_field_charge_loop_state_i_ds: self.charge_loop_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_after_state_i_ds: self.after_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_charge_loop_durations: self.charge_loop_durations = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_transient_state_i_ds: self.transient_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_next_loop_trigger_id(self): if hasattr(self, '_m_has_field_next_loop_trigger_id'): return self._m_has_field_next_loop_trigger_id self._m_has_field_next_loop_trigger_id = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_next_loop_trigger_id', None) @property def has_field_transient_state_i_ds(self): if hasattr(self, '_m_has_field_transient_state_i_ds'): return self._m_has_field_transient_state_i_ds self._m_has_field_transient_state_i_ds = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_transient_state_i_ds', None) @property def has_field_charge_loop_state_i_ds(self): if hasattr(self, '_m_has_field_charge_loop_state_i_ds'): return self._m_has_field_charge_loop_state_i_ds self._m_has_field_charge_loop_state_i_ds = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_charge_loop_state_i_ds', None) @property def has_field_allow_hold_lock_direction(self): if hasattr(self, '_m_has_field_allow_hold_lock_direction'): return self._m_has_field_allow_hold_lock_direction self._m_has_field_allow_hold_lock_direction = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_allow_hold_lock_direction', None) @property def has_field_end_hold_trigger(self): if hasattr(self, '_m_has_field_end_hold_trigger'): return self._m_has_field_end_hold_trigger self._m_has_field_end_hold_trigger = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_end_hold_trigger', None) @property def has_field_after_state_i_ds(self): if hasattr(self, '_m_has_field_after_state_i_ds'): return self._m_has_field_after_state_i_ds self._m_has_field_after_state_i_ds = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_after_state_i_ds', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_before_hold_duration(self): if hasattr(self, '_m_has_field_before_hold_duration'): return self._m_has_field_before_hold_duration self._m_has_field_before_hold_duration = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_before_hold_duration', None) @property def has_field_before_state_i_ds(self): if hasattr(self, '_m_has_field_before_state_i_ds'): return self._m_has_field_before_state_i_ds self._m_has_field_before_state_i_ds = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_before_state_i_ds', None) @property def has_field_charge_loop_durations(self): if hasattr(self, '_m_has_field_charge_loop_durations'): return self._m_has_field_charge_loop_durations self._m_has_field_charge_loop_durations = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_charge_loop_durations', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class PlaceNameConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachToMonsterAirStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_air_move: self.is_air_move = self._io.read_u1() @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_is_air_move(self): if hasattr(self, '_m_has_field_is_air_move'): return self._m_has_field_is_air_move self._m_has_field_is_air_move = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_air_move', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ProductIdConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_product_id: self.product_id = AuxTypes.String(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_internal: self.is_internal = self._io.read_u1() if self.has_field_entitlement_id: self.entitlement_id = AuxTypes.String(self._io, self, self._root) if self.has_field_catalog_item_id: self.catalog_item_id = AuxTypes.String(self._io, self, self._root) if self.has_field_platform_type_str_list: self.platform_type_str_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_catalog_item_id(self): if hasattr(self, '_m_has_field_catalog_item_id'): return self._m_has_field_catalog_item_id self._m_has_field_catalog_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_catalog_item_id', None) @property def has_field_platform_type_str_list(self): if hasattr(self, '_m_has_field_platform_type_str_list'): return self._m_has_field_platform_type_str_list self._m_has_field_platform_type_str_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_platform_type_str_list', None) @property def has_field_is_internal(self): if hasattr(self, '_m_has_field_is_internal'): return self._m_has_field_is_internal self._m_has_field_is_internal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_internal', None) @property def has_field_product_id(self): if hasattr(self, '_m_has_field_product_id'): return self._m_has_field_product_id self._m_has_field_product_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_product_id', None) @property def has_field_entitlement_id(self): if hasattr(self, '_m_has_field_entitlement_id'): return self._m_has_field_entitlement_id self._m_has_field_entitlement_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_entitlement_id', None) class BartenderEventExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetInfoPosComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSOutputSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSOutputSetting(self._io, self, self._root)) class EnumSummerTimeV2boatConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SummerTimeV2boatConditionType, self.data.value) return getattr(self, '_m_value', None) class EnumLunaRiteQuestType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LunaRiteQuestType, self.data.value) return getattr(self, '_m_value', None) class AvatarExitClimb(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigRandomQuestScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_style_dic: self.free_style_dic = Output.DictOfAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_random_free_style_dic: self.random_free_style_dic = Output.DictOfAuxTypesStringArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_free_style_dic(self): if hasattr(self, '_m_has_field_free_style_dic'): return self._m_has_field_free_style_dic self._m_has_field_free_style_dic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_free_style_dic', None) @property def has_field_random_free_style_dic(self): if hasattr(self, '_m_has_field_random_free_style_dic'): return self._m_has_field_random_free_style_dic self._m_has_field_random_free_style_dic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_random_free_style_dic', None) class MatchingTextDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_match_id: self.match_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_icon_hash: self.match_icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_icon_hash: self.match_icon_hash_pre = self._io.read_s1() if self.has_field_match_btn_name: self.match_btn_name = AuxTypes.String(self._io, self, self._root) if self.has_field_match_btn_tips: self.match_btn_tips = AuxTypes.String(self._io, self, self._root) if self.has_field_requirement_desc: self.requirement_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_limit_reason_desc: self.match_limit_reason_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_warning_desc: self.limit_warning_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_guest_desc: self.invite_guest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_host_desc: self.invite_host_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_start_desc: self.match_start_desc = AuxTypes.String(self._io, self, self._root) if self.has_field_match_title: self.match_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_success_desc: self.match_success_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_requirement_desc(self): if hasattr(self, '_m_has_field_requirement_desc'): return self._m_has_field_requirement_desc self._m_has_field_requirement_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_requirement_desc', None) @property def has_field_match_start_desc(self): if hasattr(self, '_m_has_field_match_start_desc'): return self._m_has_field_match_start_desc self._m_has_field_match_start_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_match_start_desc', None) @property def has_field_invite_guest_desc(self): if hasattr(self, '_m_has_field_invite_guest_desc'): return self._m_has_field_invite_guest_desc self._m_has_field_invite_guest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_invite_guest_desc', None) @property def has_field_match_id(self): if hasattr(self, '_m_has_field_match_id'): return self._m_has_field_match_id self._m_has_field_match_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_match_id', None) @property def has_field_limit_warning_desc(self): if hasattr(self, '_m_has_field_limit_warning_desc'): return self._m_has_field_limit_warning_desc self._m_has_field_limit_warning_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_limit_warning_desc', None) @property def has_field_match_limit_reason_desc(self): if hasattr(self, '_m_has_field_match_limit_reason_desc'): return self._m_has_field_match_limit_reason_desc self._m_has_field_match_limit_reason_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_match_limit_reason_desc', None) @property def has_field_match_btn_tips(self): if hasattr(self, '_m_has_field_match_btn_tips'): return self._m_has_field_match_btn_tips self._m_has_field_match_btn_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_match_btn_tips', None) @property def has_field_match_btn_name(self): if hasattr(self, '_m_has_field_match_btn_name'): return self._m_has_field_match_btn_name self._m_has_field_match_btn_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_match_btn_name', None) @property def has_field_match_success_desc(self): if hasattr(self, '_m_has_field_match_success_desc'): return self._m_has_field_match_success_desc self._m_has_field_match_success_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_match_success_desc', None) @property def has_field_match_icon_hash(self): if hasattr(self, '_m_has_field_match_icon_hash'): return self._m_has_field_match_icon_hash self._m_has_field_match_icon_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_match_icon_hash', None) @property def has_field_invite_host_desc(self): if hasattr(self, '_m_has_field_invite_host_desc'): return self._m_has_field_invite_host_desc self._m_has_field_invite_host_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_invite_host_desc', None) @property def has_field_match_title(self): if hasattr(self, '_m_has_field_match_title'): return self._m_has_field_match_title self._m_has_field_match_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_match_title', None) class Uint8NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ContextActionSetTextWithMainQuestName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_element: self.ui_element = Output.EnumActivityBannerUiElementType(self._io, self, self._root) if self.has_field_text_map: self.text_map = AuxTypes.String(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_ui_element(self): if hasattr(self, '_m_has_field_ui_element'): return self._m_has_field_ui_element self._m_has_field_ui_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_element', None) @property def has_field_text_map(self): if hasattr(self, '_m_has_field_text_map'): return self._m_has_field_text_map self._m_has_field_text_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_text_map', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_main_quest_id', None) class RandTaskExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_type: self.content_type = Output.EnumRandTaskContentType(self._io, self, self._root) if self.has_field_reward: self.reward = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_ui: self.need_ui = self._io.read_u1() if self.has_field_target: self.target = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enter_distance: self.enter_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exit_distance: self.exit_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward(self): if hasattr(self, '_m_has_field_reward'): return self._m_has_field_reward self._m_has_field_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_exit_distance(self): if hasattr(self, '_m_has_field_exit_distance'): return self._m_has_field_exit_distance self._m_has_field_exit_distance = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_exit_distance', None) @property def has_field_need_ui(self): if hasattr(self, '_m_has_field_need_ui'): return self._m_has_field_need_ui self._m_has_field_need_ui = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_need_ui', None) @property def has_field_enter_distance(self): if hasattr(self, '_m_has_field_enter_distance'): return self._m_has_field_enter_distance self._m_has_field_enter_distance = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_enter_distance', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_target', None) @property def has_field_content_type(self): if hasattr(self, '_m_has_field_content_type'): return self._m_has_field_content_type self._m_has_field_content_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content_type', None) class GuideOpenStateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevel1worldArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level1area: self.level1area = Output.ConfigWorldArea(self._io, self, self._root) if self.has_field_level2areas: self.level2areas = Output.ArrayOfConfigWorldAreaLengthU(self._io, self, self._root) @property def has_field_level1area(self): if hasattr(self, '_m_has_field_level1area'): return self._m_has_field_level1area self._m_has_field_level1area = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level1area', None) @property def has_field_level2areas(self): if hasattr(self, '_m_has_field_level2areas'): return self._m_has_field_level2areas self._m_has_field_level2areas = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_level2areas', None) class ConfigLevelMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_meta_dic: self.scene_meta_dic = Output.DictOfAuxTypesVlqBase128LeUConfigSceneMeta(self._io, self, self._root) @property def has_field_scene_meta_dic(self): if hasattr(self, '_m_has_field_scene_meta_dic'): return self._m_has_field_scene_meta_dic self._m_has_field_scene_meta_dic = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_meta_dic', None) class ConfigClimateInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TileAttackMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_id: self.attack_id = AuxTypes.String(self._io, self, self._root) @property def has_field_attack_id(self): if hasattr(self, '_m_has_field_attack_id'): return self._m_has_field_attack_id self._m_has_field_attack_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigEffectItanoCircusBullet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMultiBullet(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def select_target_default_type(self): if hasattr(self, '_m_select_target_default_type'): return self._m_select_target_default_type self._m_select_target_default_type = self.base.select_target_default_type return getattr(self, '_m_select_target_default_type', None) class EnumLimitRegionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LimitRegionType, self.data.value) return getattr(self, '_m_value', None) class ItemUseTargetComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LevelTagExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChallengeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChallengeType, self.data.value) return getattr(self, '_m_value', None) class ShopRefreshTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomMainQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lua_path: self.lua_path = AuxTypes.String(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_repeatable: self.repeatable = self._io.read_u1() if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_suggest_track_main_quest_list: self.suggest_track_main_quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_suggest_track_out_of_order: self.suggest_track_out_of_order = self._io.read_u1() if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_list: self.reward_id_list = AuxTypes.String(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_repeatable(self): if hasattr(self, '_m_has_field_repeatable'): return self._m_has_field_repeatable self._m_has_field_repeatable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_repeatable', None) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_reward_id_list(self): if hasattr(self, '_m_has_field_reward_id_list'): return self._m_has_field_reward_id_list self._m_has_field_reward_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_reward_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_lua_path(self): if hasattr(self, '_m_has_field_lua_path'): return self._m_has_field_lua_path self._m_has_field_lua_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_lua_path', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_suggest_track_out_of_order(self): if hasattr(self, '_m_has_field_suggest_track_out_of_order'): return self._m_has_field_suggest_track_out_of_order self._m_has_field_suggest_track_out_of_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_suggest_track_out_of_order', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_active_mode', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_show_type', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_suggest_track_main_quest_list(self): if hasattr(self, '_m_has_field_suggest_track_main_quest_list'): return self._m_has_field_suggest_track_main_quest_list self._m_has_field_suggest_track_main_quest_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_suggest_track_main_quest_list', None) class HandbookQuestGuideHintPicExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_pic_id: self.pic_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_image_path: self.image_path = AuxTypes.String(self._io, self, self._root) @property def has_field_pic_id(self): if hasattr(self, '_m_has_field_pic_id'): return self._m_has_field_pic_id self._m_has_field_pic_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_pic_id', None) @property def has_field_image_path(self): if hasattr(self, '_m_has_field_image_path'): return self._m_has_field_image_path self._m_has_field_image_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_image_path', None) class EnvAnimalGatherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_animal_id: self.animal_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_gather_item_list: self.gather_item_list = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_escape_radius: self.escape_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_escape_time: self.escape_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_alive_time: self.alive_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exclude_weathers: self.exclude_weathers = AuxTypes.String(self._io, self, self._root) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_entity_type', None) @property def has_field_escape_radius(self): if hasattr(self, '_m_has_field_escape_radius'): return self._m_has_field_escape_radius self._m_has_field_escape_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_escape_radius', None) @property def has_field_alive_time(self): if hasattr(self, '_m_has_field_alive_time'): return self._m_has_field_alive_time self._m_has_field_alive_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_alive_time', None) @property def has_field_exclude_weathers(self): if hasattr(self, '_m_has_field_exclude_weathers'): return self._m_has_field_exclude_weathers self._m_has_field_exclude_weathers = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_exclude_weathers', None) @property def has_field_escape_time(self): if hasattr(self, '_m_has_field_escape_time'): return self._m_has_field_escape_time self._m_has_field_escape_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_escape_time', None) @property def has_field_animal_id(self): if hasattr(self, '_m_has_field_animal_id'): return self._m_has_field_animal_id self._m_has_field_animal_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_animal_id', None) @property def has_field_gather_item_list(self): if hasattr(self, '_m_has_field_gather_item_list'): return self._m_has_field_gather_item_list self._m_has_field_gather_item_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gather_item_list', None) class NewActivityScoreLimitExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_value: self.limit_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_limit_value(self): if hasattr(self, '_m_has_field_limit_value'): return self._m_has_field_limit_value self._m_has_field_limit_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_limit_value', None) class DictOfEnumOptionTypeConfigPostprocessEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumOptionTypeConfigPostprocessEffectSetting(self._io, self, self._root)) class EnumAvatarFilterType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AvatarFilterType, self.data.value) return getattr(self, '_m_value', None) class ConfigAudioLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_teleport_events: self.teleport_events = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_state_group: self.state_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dungeon_event_map: self.dungeon_event_map = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) @property def has_field_teleport_events(self): if hasattr(self, '_m_has_field_teleport_events'): return self._m_has_field_teleport_events self._m_has_field_teleport_events = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_teleport_events', None) @property def has_field_state_group(self): if hasattr(self, '_m_has_field_state_group'): return self._m_has_field_state_group self._m_has_field_state_group = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_group', None) @property def has_field_dungeon_event_map(self): if hasattr(self, '_m_has_field_dungeon_event_map'): return self._m_has_field_dungeon_event_map self._m_has_field_dungeon_event_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dungeon_event_map', None) class ConfigGuideButtonClickCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_button_path: self.button_path = AuxTypes.String(self._io, self, self._root) if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_page_type: self.page_type = Output.EnumGuidePageType(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGuideButtonClick(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_special: self.special = Output.EnumGuideWidgetSpecialType(self._io, self, self._root) if self.has_field_special_index: self.special_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_long_press_type: self.long_press_type = Output.EnumGuideLongPressType(self._io, self, self._root) if self.has_field_force_last_click: self.force_last_click = self._io.read_u1() @property def has_field_special_index(self): if hasattr(self, '_m_has_field_special_index'): return self._m_has_field_special_index self._m_has_field_special_index = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_special_index', None) @property def has_field_force_last_click(self): if hasattr(self, '_m_has_field_force_last_click'): return self._m_has_field_force_last_click self._m_has_field_force_last_click = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_force_last_click', None) @property def has_field_long_press_type(self): if hasattr(self, '_m_has_field_long_press_type'): return self._m_has_field_long_press_type self._m_has_field_long_press_type = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_long_press_type', None) @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_context_name', None) @property def has_field_button_path(self): if hasattr(self, '_m_has_field_button_path'): return self._m_has_field_button_path self._m_has_field_button_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_button_path', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_page_type(self): if hasattr(self, '_m_has_field_page_type'): return self._m_has_field_page_type self._m_has_field_page_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_page_type', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def has_field_special(self): if hasattr(self, '_m_has_field_special'): return self._m_has_field_special self._m_has_field_special = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_special', None) class AttachActionToModifierMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_added: self.on_added = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_removed: self.on_removed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_added(self): if hasattr(self, '_m_has_field_on_added'): return self._m_has_field_on_added self._m_has_field_on_added = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_added', None) @property def has_field_on_removed(self): if hasattr(self, '_m_has_field_on_removed'): return self._m_has_field_on_removed self._m_has_field_on_removed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_removed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ExpeditionBonusExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerSetShadowRamp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_use_shadow_ramp: self.use_shadow_ramp = self._io.read_u1() if self.has_field_special_mats: self.special_mats = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_special_mats(self): if hasattr(self, '_m_has_field_special_mats'): return self._m_has_field_special_mats self._m_has_field_special_mats = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_special_mats', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_use_shadow_ramp(self): if hasattr(self, '_m_has_field_use_shadow_ramp'): return self._m_has_field_use_shadow_ramp self._m_has_field_use_shadow_ramp = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_shadow_ramp', None) class ConfigCodexQuestText(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_text_id: self.text_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_text_type: self.text_type = Output.EnumCodexQuestTextType(self._io, self, self._root) @property def has_field_text_id(self): if hasattr(self, '_m_has_field_text_id'): return self._m_has_field_text_id self._m_has_field_text_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_text_id', None) @property def has_field_text_type(self): if hasattr(self, '_m_has_field_text_type'): return self._m_has_field_text_type self._m_has_field_text_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_text_type', None) class SoloConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_solo_start: self.solo_start = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_solo_end: self.solo_end = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_self: self.is_self = self._io.read_u1() @property def has_field_solo_start(self): if hasattr(self, '_m_has_field_solo_start'): return self._m_has_field_solo_start self._m_has_field_solo_start = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_solo_start', None) @property def has_field_solo_end(self): if hasattr(self, '_m_has_field_solo_end'): return self._m_has_field_solo_end self._m_has_field_solo_end = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_solo_end', None) @property def has_field_is_self(self): if hasattr(self, '_m_has_field_is_self'): return self._m_has_field_is_self self._m_has_field_is_self = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_self', None) class DispConfigCoopBaseNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigCoopBaseNode(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigCoopActionNode(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCoopTalkNode(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigCoopSelectNode(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigCoopEndNode(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCoopCondNode(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivityDeliveryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_config_id_list: self.daily_config_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_need_player_level: self.need_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_daily_config_id_list(self): if hasattr(self, '_m_has_field_daily_config_id_list'): return self._m_has_field_daily_config_id_list self._m_has_field_daily_config_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_daily_config_id_list', None) @property def has_field_need_player_level(self): if hasattr(self, '_m_has_field_need_player_level'): return self._m_has_field_need_player_level self._m_has_field_need_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_need_player_level', None) class DictOfAuxTypesVlqBase128LeUVector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUVector(self._io, self, self._root)) class HasShieldTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class StrikeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHomeworldGroupUnit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_parent_index: self.parent_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_parent_index(self): if hasattr(self, '_m_has_field_parent_index'): return self._m_has_field_parent_index self._m_has_field_parent_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_parent_index', None) class ConfigMusicUInt32listPartialPresenceCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listMultiMemberCondition(self._io, self, self._root) @property def values(self): if hasattr(self, '_m_values'): return self._m_values self._m_values = self.base.values return getattr(self, '_m_values', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class IconAdsorbEffectExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrStreamLayerRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SelectActionPointByTargetOrientation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_point_i_ds: self.action_point_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_angle: self.angle = self._io.read_f4le() if self.has_field_sign_type: self.sign_type = self._io.read_u1() @property def has_field_action_point_i_ds(self): if hasattr(self, '_m_has_field_action_point_i_ds'): return self._m_has_field_action_point_i_ds self._m_has_field_action_point_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_point_i_ds', None) @property def has_field_angle(self): if hasattr(self, '_m_has_field_angle'): return self._m_has_field_angle self._m_has_field_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_angle', None) @property def has_field_sign_type(self): if hasattr(self, '_m_has_field_sign_type'): return self._m_has_field_sign_type self._m_has_field_sign_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sign_type', None) class ArrayOfConfigAudioQuestOpsLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAudioQuestOps(self._io, self, self._root)) class FireworksFactorExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reform_param_type: self.reform_param_type = Output.EnumFireworksReformParamType(self._io, self, self._root) if self.has_field_param_name: self.param_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param_icon: self.param_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_adjust_left_desc: self.adjust_left_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_adjust_right_desc: self.adjust_right_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_description_format: self.description_format = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_adjust_factor: self.adjust_factor = self._io.read_f4le() @property def has_field_param_name(self): if hasattr(self, '_m_has_field_param_name'): return self._m_has_field_param_name self._m_has_field_param_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_name', None) @property def has_field_reform_param_type(self): if hasattr(self, '_m_has_field_reform_param_type'): return self._m_has_field_reform_param_type self._m_has_field_reform_param_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reform_param_type', None) @property def has_field_adjust_right_desc(self): if hasattr(self, '_m_has_field_adjust_right_desc'): return self._m_has_field_adjust_right_desc self._m_has_field_adjust_right_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_adjust_right_desc', None) @property def has_field_adjust_left_desc(self): if hasattr(self, '_m_has_field_adjust_left_desc'): return self._m_has_field_adjust_left_desc self._m_has_field_adjust_left_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_adjust_left_desc', None) @property def has_field_param_icon(self): if hasattr(self, '_m_has_field_param_icon'): return self._m_has_field_param_icon self._m_has_field_param_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param_icon', None) @property def has_field_adjust_factor(self): if hasattr(self, '_m_has_field_adjust_factor'): return self._m_has_field_adjust_factor self._m_has_field_adjust_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_adjust_factor', None) @property def has_field_description_format(self): if hasattr(self, '_m_has_field_description_format'): return self._m_has_field_description_format self._m_has_field_description_format = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_description_format', None) class ByLocalAvatarStaminaRatio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_stamina_ratio: self.stamina_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_stamina_ratio(self): if hasattr(self, '_m_has_field_stamina_ratio'): return self._m_has_field_stamina_ratio self._m_has_field_stamina_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stamina_ratio', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class InvestigationTargetConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_investigation_id: self.investigation_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_image: self.image = AuxTypes.String(self._io, self, self._root) if self.has_field_info_des: self.info_des = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide: self.guide = Output.QuestGuide(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_info_des(self): if hasattr(self, '_m_has_field_info_des'): return self._m_has_field_info_des self._m_has_field_info_des = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_info_des', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_image(self): if hasattr(self, '_m_has_field_image'): return self._m_has_field_image self._m_has_field_image = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_image', None) @property def has_field_guide(self): if hasattr(self, '_m_has_field_guide'): return self._m_has_field_guide self._m_has_field_guide = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_guide', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_investigation_id(self): if hasattr(self, '_m_has_field_investigation_id'): return self._m_has_field_investigation_id self._m_has_field_investigation_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_investigation_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class VolatileTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDirectionByGroundNormalRange(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_range: self.range = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_range', None) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class ConfigTalkScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_way: self.begin_way = Output.EnumTalkBeginWay(self._io, self, self._root) if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_begin_cond_comb: self.begin_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_begin_cond: self.begin_cond = Output.ArrayOfTalkCondExLengthU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_talks: self.next_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_next_random_talks: self.next_random_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_random_talk_count: self.show_random_talk_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_init_dialog: self.init_dialog = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_decorator_id: self.decorator_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_perform_cfg: self.perform_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_hero_talk: self.hero_talk = Output.EnumTalkHeroType(self._io, self, self._root) if self.has_field_load_type: self.load_type = Output.EnumTalkLoadType(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_load_mark_id: self.extra_load_mark_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_asset_index: self.asset_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dont_block_daily: self.dont_block_daily = self._io.read_u1() if self.has_field_participant_id: self.participant_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pre_perform_cfg: self.pre_perform_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_stay_free_style: self.stay_free_style = self._io.read_u1() if self.has_field_enable_camera_displacement: self.enable_camera_displacement = self._io.read_u1() if self.has_field_lock_game_time: self.lock_game_time = self._io.read_u1() if self.has_field_talk_mark_type: self.talk_mark_type = Output.EnumTalkMarkType(self._io, self, self._root) if self.has_field_quest_idle_talk: self.quest_idle_talk = self._io.read_u1() if self.has_field_low_priority: self.low_priority = self._io.read_u1() if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfTalkExecExLengthU(self._io, self, self._root) if self.has_field_pre_perform_free_style_list: self.pre_perform_free_style_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_free_style_list: self.free_style_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_talk_mark_hide_list: self.talk_mark_hide_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_crowd_lod0list: self.crowd_lod0list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_participant_id(self): if hasattr(self, '_m_has_field_participant_id'): return self._m_has_field_participant_id self._m_has_field_participant_id = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_participant_id', None) @property def has_field_perform_cfg(self): if hasattr(self, '_m_has_field_perform_cfg'): return self._m_has_field_perform_cfg self._m_has_field_perform_cfg = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_perform_cfg', None) @property def has_field_quest_idle_talk(self): if hasattr(self, '_m_has_field_quest_idle_talk'): return self._m_has_field_quest_idle_talk self._m_has_field_quest_idle_talk = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_quest_idle_talk', None) @property def has_field_init_dialog(self): if hasattr(self, '_m_has_field_init_dialog'): return self._m_has_field_init_dialog self._m_has_field_init_dialog = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_init_dialog', None) @property def has_field_free_style_list(self): if hasattr(self, '_m_has_field_free_style_list'): return self._m_has_field_free_style_list self._m_has_field_free_style_list = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_free_style_list', None) @property def has_field_lock_game_time(self): if hasattr(self, '_m_has_field_lock_game_time'): return self._m_has_field_lock_game_time self._m_has_field_lock_game_time = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_lock_game_time', None) @property def has_field_pre_perform_free_style_list(self): if hasattr(self, '_m_has_field_pre_perform_free_style_list'): return self._m_has_field_pre_perform_free_style_list self._m_has_field_pre_perform_free_style_list = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_pre_perform_free_style_list', None) @property def has_field_begin_way(self): if hasattr(self, '_m_has_field_begin_way'): return self._m_has_field_begin_way self._m_has_field_begin_way = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_begin_way', None) @property def has_field_next_talks(self): if hasattr(self, '_m_has_field_next_talks'): return self._m_has_field_next_talks self._m_has_field_next_talks = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_next_talks', None) @property def has_field_pre_perform_cfg(self): if hasattr(self, '_m_has_field_pre_perform_cfg'): return self._m_has_field_pre_perform_cfg self._m_has_field_pre_perform_cfg = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_pre_perform_cfg', None) @property def has_field_begin_cond_comb(self): if hasattr(self, '_m_has_field_begin_cond_comb'): return self._m_has_field_begin_cond_comb self._m_has_field_begin_cond_comb = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_begin_cond_comb', None) @property def has_field_extra_load_mark_id(self): if hasattr(self, '_m_has_field_extra_load_mark_id'): return self._m_has_field_extra_load_mark_id self._m_has_field_extra_load_mark_id = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_extra_load_mark_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_next_random_talks(self): if hasattr(self, '_m_has_field_next_random_talks'): return self._m_has_field_next_random_talks self._m_has_field_next_random_talks = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_next_random_talks', None) @property def has_field_talk_mark_type(self): if hasattr(self, '_m_has_field_talk_mark_type'): return self._m_has_field_talk_mark_type self._m_has_field_talk_mark_type = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_talk_mark_type', None) @property def has_field_crowd_lod0list(self): if hasattr(self, '_m_has_field_crowd_lod0list'): return self._m_has_field_crowd_lod0list self._m_has_field_crowd_lod0list = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_crowd_lod0list', None) @property def has_field_decorator_id(self): if hasattr(self, '_m_has_field_decorator_id'): return self._m_has_field_decorator_id self._m_has_field_decorator_id = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_decorator_id', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_finish_exec', None) @property def has_field_dont_block_daily(self): if hasattr(self, '_m_has_field_dont_block_daily'): return self._m_has_field_dont_block_daily self._m_has_field_dont_block_daily = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_dont_block_daily', None) @property def has_field_enable_camera_displacement(self): if hasattr(self, '_m_has_field_enable_camera_displacement'): return self._m_has_field_enable_camera_displacement self._m_has_field_enable_camera_displacement = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_enable_camera_displacement', None) @property def has_field_show_random_talk_count(self): if hasattr(self, '_m_has_field_show_random_talk_count'): return self._m_has_field_show_random_talk_count self._m_has_field_show_random_talk_count = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_show_random_talk_count', None) @property def has_field_begin_cond(self): if hasattr(self, '_m_has_field_begin_cond'): return self._m_has_field_begin_cond self._m_has_field_begin_cond = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_begin_cond', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_active_mode', None) @property def has_field_load_type(self): if hasattr(self, '_m_has_field_load_type'): return self._m_has_field_load_type self._m_has_field_load_type = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_load_type', None) @property def has_field_talk_mark_hide_list(self): if hasattr(self, '_m_has_field_talk_mark_hide_list'): return self._m_has_field_talk_mark_hide_list self._m_has_field_talk_mark_hide_list = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_talk_mark_hide_list', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_npc_id', None) @property def has_field_low_priority(self): if hasattr(self, '_m_has_field_low_priority'): return self._m_has_field_low_priority self._m_has_field_low_priority = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_low_priority', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_hero_talk(self): if hasattr(self, '_m_has_field_hero_talk'): return self._m_has_field_hero_talk self._m_has_field_hero_talk = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_hero_talk', None) @property def has_field_stay_free_style(self): if hasattr(self, '_m_has_field_stay_free_style'): return self._m_has_field_stay_free_style self._m_has_field_stay_free_style = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_stay_free_style', None) @property def has_field_asset_index(self): if hasattr(self, '_m_has_field_asset_index'): return self._m_has_field_asset_index self._m_has_field_asset_index = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_asset_index', None) class DictOfAuxTypesStringArrayOfF4LengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfF4LengthU(self._io, self, self._root)) class CrowdSpawnConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarCostumeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCircleDetectDirection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CircleDetectDirection, self.data.value) return getattr(self, '_m_value', None) class ContextActionSelectLegendQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_legend_quest_id: self.legend_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_legend_quest_id(self): if hasattr(self, '_m_has_field_legend_quest_id'): return self._m_has_field_legend_quest_id self._m_has_field_legend_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_legend_quest_id', None) class DictOfAuxTypesVlqBase128LeSConfigAiReactActionPointData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiReactActionPointData(self._io, self, self._root)) class OnEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CondfigAiRangeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductCardDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_card_product_type: self.card_product_type = Output.EnumCardProductType(self._io, self, self._root) if self.has_field_item_name: self.item_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_total_limit_days: self.total_limit_days = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_days: self.days = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hcoin_per_day: self.hcoin_per_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mcoin_base: self.mcoin_base = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_base_item_map: self.base_item_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_per_day_item_map: self.per_day_item_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_replace_mcoin_num: self.replace_mcoin_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_first_reward_text: self.first_reward_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_reward_text: self.daily_reward_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_reward_text: self.total_reward_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_days_text: self.total_days_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_remain_days_text: self.remain_days_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_remain_days_text2: self.remain_days_text2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explain_title: self.explain_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explain_desc: self.explain_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_level: self.sort_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_explain_desc(self): if hasattr(self, '_m_has_field_explain_desc'): return self._m_has_field_explain_desc self._m_has_field_explain_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_explain_desc', None) @property def has_field_base_item_map(self): if hasattr(self, '_m_has_field_base_item_map'): return self._m_has_field_base_item_map self._m_has_field_base_item_map = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_base_item_map', None) @property def has_field_daily_reward_text(self): if hasattr(self, '_m_has_field_daily_reward_text'): return self._m_has_field_daily_reward_text self._m_has_field_daily_reward_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_daily_reward_text', None) @property def has_field_days(self): if hasattr(self, '_m_has_field_days'): return self._m_has_field_days self._m_has_field_days = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_days', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_total_reward_text(self): if hasattr(self, '_m_has_field_total_reward_text'): return self._m_has_field_total_reward_text self._m_has_field_total_reward_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_total_reward_text', None) @property def has_field_sort_level(self): if hasattr(self, '_m_has_field_sort_level'): return self._m_has_field_sort_level self._m_has_field_sort_level = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_sort_level', None) @property def has_field_remain_days_text(self): if hasattr(self, '_m_has_field_remain_days_text'): return self._m_has_field_remain_days_text self._m_has_field_remain_days_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_remain_days_text', None) @property def has_field_total_days_text(self): if hasattr(self, '_m_has_field_total_days_text'): return self._m_has_field_total_days_text self._m_has_field_total_days_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_total_days_text', None) @property def has_field_remain_days_text2(self): if hasattr(self, '_m_has_field_remain_days_text2'): return self._m_has_field_remain_days_text2 self._m_has_field_remain_days_text2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_remain_days_text2', None) @property def has_field_mcoin_base(self): if hasattr(self, '_m_has_field_mcoin_base'): return self._m_has_field_mcoin_base self._m_has_field_mcoin_base = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_mcoin_base', None) @property def has_field_replace_mcoin_num(self): if hasattr(self, '_m_has_field_replace_mcoin_num'): return self._m_has_field_replace_mcoin_num self._m_has_field_replace_mcoin_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_replace_mcoin_num', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_total_limit_days(self): if hasattr(self, '_m_has_field_total_limit_days'): return self._m_has_field_total_limit_days self._m_has_field_total_limit_days = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_total_limit_days', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_card_product_type(self): if hasattr(self, '_m_has_field_card_product_type'): return self._m_has_field_card_product_type self._m_has_field_card_product_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_card_product_type', None) @property def has_field_item_name(self): if hasattr(self, '_m_has_field_item_name'): return self._m_has_field_item_name self._m_has_field_item_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_name', None) @property def has_field_per_day_item_map(self): if hasattr(self, '_m_has_field_per_day_item_map'): return self._m_has_field_per_day_item_map self._m_has_field_per_day_item_map = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_per_day_item_map', None) @property def has_field_explain_title(self): if hasattr(self, '_m_has_field_explain_title'): return self._m_has_field_explain_title self._m_has_field_explain_title = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_explain_title', None) @property def has_field_first_reward_text(self): if hasattr(self, '_m_has_field_first_reward_text'): return self._m_has_field_first_reward_text self._m_has_field_first_reward_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_first_reward_text', None) @property def has_field_hcoin_per_day(self): if hasattr(self, '_m_has_field_hcoin_per_day'): return self._m_has_field_hcoin_per_day self._m_has_field_hcoin_per_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_hcoin_per_day', None) class SectrCombineStreamPathInfoRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideAvatarStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigBladeElementFx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigBladeElementFx(self._io, self, self._root) class KillServerGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_info: self.gadget_info = Output.SelectTargetsByChildren(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_gadget_info(self): if hasattr(self, '_m_has_field_gadget_info'): return self._m_has_field_gadget_info self._m_has_field_gadget_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_info', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RegionSearchRegionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_center: self.region_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_region_radius: self.region_radius = self._io.read_f4le() if self.has_field_oneoff_group_list: self.oneoff_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_oneoff_group_num: self.oneoff_group_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recycle_group_list: self.recycle_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_recycle_group_num: self.recycle_group_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recycle_type: self.recycle_type = Output.EnumRegionSearchRecycleType(self._io, self, self._root) if self.has_field_recycle_param: self.recycle_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_oneoff_group_list(self): if hasattr(self, '_m_has_field_oneoff_group_list'): return self._m_has_field_oneoff_group_list self._m_has_field_oneoff_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_oneoff_group_list', None) @property def has_field_recycle_group_num(self): if hasattr(self, '_m_has_field_recycle_group_num'): return self._m_has_field_recycle_group_num self._m_has_field_recycle_group_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_recycle_group_num', None) @property def has_field_region_radius(self): if hasattr(self, '_m_has_field_region_radius'): return self._m_has_field_region_radius self._m_has_field_region_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_region_radius', None) @property def has_field_recycle_param(self): if hasattr(self, '_m_has_field_recycle_param'): return self._m_has_field_recycle_param self._m_has_field_recycle_param = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_recycle_param', None) @property def has_field_recycle_type(self): if hasattr(self, '_m_has_field_recycle_type'): return self._m_has_field_recycle_type self._m_has_field_recycle_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_recycle_type', None) @property def has_field_region_center(self): if hasattr(self, '_m_has_field_region_center'): return self._m_has_field_region_center self._m_has_field_region_center = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_region_center', None) @property def has_field_oneoff_group_num(self): if hasattr(self, '_m_has_field_oneoff_group_num'): return self._m_has_field_oneoff_group_num self._m_has_field_oneoff_group_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_oneoff_group_num', None) @property def has_field_recycle_group_list(self): if hasattr(self, '_m_has_field_recycle_group_list'): return self._m_has_field_recycle_group_list self._m_has_field_recycle_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_recycle_group_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class EnumPointMapVisibility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PointMapVisibility, self.data.value) return getattr(self, '_m_value', None) class ConfigHomePlaceColPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_place_col_path: self.place_col_path = Output.DictOfAuxTypesStringArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_place_col_path(self): if hasattr(self, '_m_has_field_place_col_path'): return self._m_has_field_place_col_path self._m_has_field_place_col_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_place_col_path', None) class ConfigGuideCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseGuide(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_general_condition_type: self.general_condition_type = Output.EnumGuideGeneralConditionType(self._io, self, self._root) if self.has_field_general_condition_val: self.general_condition_val = self._io.read_u1() @property def has_field_general_condition_type(self): if hasattr(self, '_m_has_field_general_condition_type'): return self._m_has_field_general_condition_type self._m_has_field_general_condition_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_general_condition_type', None) @property def has_field_general_condition_val(self): if hasattr(self, '_m_has_field_general_condition_val'): return self._m_has_field_general_condition_val self._m_has_field_general_condition_val = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_general_condition_val', None) class ConfigWidgetToyOneoffGatherPointDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_radius: self.hint_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_nearby_radius: self.nearby_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grid_search_range: self.grid_search_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_gadget_id: self.success_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_failed_gadget_id: self.failed_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_point_type: self.gather_point_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_last_time: self.effect_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_success_gadget_id(self): if hasattr(self, '_m_has_field_success_gadget_id'): return self._m_has_field_success_gadget_id self._m_has_field_success_gadget_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_success_gadget_id', None) @property def has_field_nearby_radius(self): if hasattr(self, '_m_has_field_nearby_radius'): return self._m_has_field_nearby_radius self._m_has_field_nearby_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_nearby_radius', None) @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_hint_group', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_effect_last_time(self): if hasattr(self, '_m_has_field_effect_last_time'): return self._m_has_field_effect_last_time self._m_has_field_effect_last_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_effect_last_time', None) @property def has_field_gather_point_type(self): if hasattr(self, '_m_has_field_gather_point_type'): return self._m_has_field_gather_point_type self._m_has_field_gather_point_type = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gather_point_type', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_hint_radius(self): if hasattr(self, '_m_has_field_hint_radius'): return self._m_has_field_hint_radius self._m_has_field_hint_radius = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_hint_radius', None) @property def has_field_grid_search_range(self): if hasattr(self, '_m_has_field_grid_search_range'): return self._m_has_field_grid_search_range self._m_has_field_grid_search_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_grid_search_range', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def has_field_failed_gadget_id(self): if hasattr(self, '_m_has_field_failed_gadget_id'): return self._m_has_field_failed_gadget_id self._m_has_field_failed_gadget_id = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_failed_gadget_id', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class TextMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySumoDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scheduld_id: self.scheduld_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumSumoDifficultyType(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_level: self.dungeon_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ratio: self.ratio = self._io.read_f4le() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_scheduld_id(self): if hasattr(self, '_m_has_field_scheduld_id'): return self._m_has_field_scheduld_id self._m_has_field_scheduld_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scheduld_id', None) @property def has_field_dungeon_level(self): if hasattr(self, '_m_has_field_dungeon_level'): return self._m_has_field_dungeon_level self._m_has_field_dungeon_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_dungeon_level', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_ratio', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ArrayOfBlessingPicUpConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BlessingPicUpConfig(self._io, self, self._root)) class EnumFlowSuiteOperatePolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FlowSuiteOperatePolicy, self.data.value) return getattr(self, '_m_value', None) class ApplyModifierWithSharedDurabilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAnimPatternPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_anim_pattern_paths: self.anim_pattern_paths = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_anim_pattern_paths(self): if hasattr(self, '_m_has_field_anim_pattern_paths'): return self._m_has_field_anim_pattern_paths self._m_has_field_anim_pattern_paths = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_anim_pattern_paths', None) class AttachModifierToHpPercentMixinV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_delay_frame_count: self.delay_frame_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_need_flush_on_removed: self.is_need_flush_on_removed = self._io.read_u1() @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_is_need_flush_on_removed(self): if hasattr(self, '_m_has_field_is_need_flush_on_removed'): return self._m_has_field_is_need_flush_on_removed self._m_has_field_is_need_flush_on_removed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_need_flush_on_removed', None) @property def has_field_delay_frame_count(self): if hasattr(self, '_m_has_field_delay_frame_count'): return self._m_has_field_delay_frame_count self._m_has_field_delay_frame_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_delay_frame_count', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class EnumWeatherType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WeatherType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfAudioStateOpLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioStateOp(self._io, self, self._root)) class ConfigGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEntity(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_equip: self.has_equip = self._io.read_u1() if self.has_field_has_audio: self.has_audio = self._io.read_u1() if self.has_field_has_model: self.has_model = self._io.read_u1() if self.has_field_has_ability: self.has_ability = self._io.read_u1() if self.has_field_has_dither: self.has_dither = self._io.read_u1() if self.has_field_has_follow_wind_zone_rotation: self.has_follow_wind_zone_rotation = self._io.read_u1() if self.has_field_force_dont_use_update_rigidbody: self.force_dont_use_update_rigidbody = self._io.read_u1() if self.has_field_has_connect_trigger: self.has_connect_trigger = self._io.read_u1() if self.has_field_can_be_created_on_platform: self.can_be_created_on_platform = self._io.read_u1() if self.has_field_connect_trigger_priority: self.connect_trigger_priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ignore_child_scene_prop: self.ignore_child_scene_prop = self._io.read_u1() if self.has_field_move_refresh_ground_force_up: self.move_refresh_ground_force_up = self._io.read_u1() if self.has_field_combat: self.combat = Output.ConfigCombat(self._io, self, self._root) if self.has_field_combat_template: self.combat_template = AuxTypes.String(self._io, self, self._root) if self.has_field_abilities: self.abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_field: self.field = Output.ConfigTrigger(self._io, self, self._root) if self.has_field_timer: self.timer = Output.ConfigTimer(self._io, self, self._root) if self.has_field_move: self.move = Output.DispConfigMove(self._io, self, self._root) if self.has_field_gadget: self.gadget = Output.DispConfigGadgetPattern(self._io, self, self._root) if self.has_field_equipment: self.equipment = Output.ConfigEquipment(self._io, self, self._root) if self.has_field_navigation: self.navigation = Output.ConfigNavigation(self._io, self, self._root) if self.has_field_ui_interact: self.ui_interact = Output.ConfigGadgetUi(self._io, self, self._root) if self.has_field_misc: self.misc = Output.ConfigGadgetMisc(self._io, self, self._root) if self.has_field_state_layers: self.state_layers = Output.DictOfAuxTypesStringDispConfigBaseStateLayer(self._io, self, self._root) if self.has_field_audio: self.audio = Output.DispConfigEntityAudio(self._io, self, self._root) if self.has_field_aibeta: self.aibeta = Output.ConfigAiBeta(self._io, self, self._root) if self.has_field_weather: self.weather = Output.ConfigWeather(self._io, self, self._root) if self.has_field_wall: self.wall = Output.ConfigWall(self._io, self, self._root) if self.has_field_face: self.face = Output.ConfigFace(self._io, self, self._root) if self.has_field_part_control: self.part_control = Output.ConfigPartController(self._io, self, self._root) if self.has_field_paimon: self.paimon = Output.ConfigPaimon(self._io, self, self._root) if self.has_field_radar_hint: self.radar_hint = self._io.read_u1() if self.has_field_keep_modifier_out_sight: self.keep_modifier_out_sight = self._io.read_u1() if self.has_field_gadget_action: self.gadget_action = Output.ConfigGadgetAction(self._io, self, self._root) if self.has_field_gadget_turn: self.gadget_turn = Output.DispConfigGadgetTurn(self._io, self, self._root) if self.has_field_gv_turn: self.gv_turn = Output.ConfigGlobalValueTurn(self._io, self, self._root) if self.has_field_billboard: self.billboard = Output.DispConfigBillboard(self._io, self, self._root) if self.has_field_intee: self.intee = Output.ConfigIntee(self._io, self, self._root) if self.has_field_bind_emotions: self.bind_emotions = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_projector: self.projector = self._io.read_u1() if self.has_field_low_priority_intee: self.low_priority_intee = self._io.read_u1() if self.has_field_can_remove_by_client: self.can_remove_by_client = self._io.read_u1() if self.has_field_tags: self.tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_can_be_triggered_by_avatar_ray: self.can_be_triggered_by_avatar_ray = self._io.read_u1() if self.has_field_vehicle: self.vehicle = Output.ConfigVehicle(self._io, self, self._root) if self.has_field_dangerzone: self.dangerzone = Output.ConfigDangerZone(self._io, self, self._root) if self.has_field_fishing_zone: self.fishing_zone = Output.ConfigFishingZone(self._io, self, self._root) if self.has_field_force_set_entity_type: self.force_set_entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_camera_adjust: self.camera_adjust = Output.ConfigGadgetSpecialCamera(self._io, self, self._root) if self.has_field_vod_intee: self.vod_intee = Output.ConfigVodIntee(self._io, self, self._root) if self.has_field_vod_player: self.vod_player = Output.ConfigLivePlayer(self._io, self, self._root) if self.has_field_camera_box: self.camera_box = Output.ConfigGadgetCameraBox(self._io, self, self._root) if self.has_field_open_watcher: self.open_watcher = self._io.read_u1() if self.has_field_ray_tag: self.ray_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_ray_tag: self.has_ray_tag = self._io.read_u1() if self.has_field_use_retreat_type: self.use_retreat_type = self._io.read_u1() if self.has_field_dont_destroy_by_perform: self.dont_destroy_by_perform = self._io.read_u1() @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def has_field_vod_intee(self): if hasattr(self, '_m_has_field_vod_intee'): return self._m_has_field_vod_intee self._m_has_field_vod_intee = (self.bit_field.value & 562949953421312) != 0 return getattr(self, '_m_has_field_vod_intee', None) @property def has_field_has_connect_trigger(self): if hasattr(self, '_m_has_field_has_connect_trigger'): return self._m_has_field_has_connect_trigger self._m_has_field_has_connect_trigger = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_has_connect_trigger', None) @property def has_field_gadget(self): if hasattr(self, '_m_has_field_gadget'): return self._m_has_field_gadget self._m_has_field_gadget = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_gadget', None) @property def has_field_open_watcher(self): if hasattr(self, '_m_has_field_open_watcher'): return self._m_has_field_open_watcher self._m_has_field_open_watcher = (self.bit_field.value & 4503599627370496) != 0 return getattr(self, '_m_has_field_open_watcher', None) @property def has_field_face(self): if hasattr(self, '_m_has_field_face'): return self._m_has_field_face self._m_has_field_face = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_face', None) @property def has_field_combat_template(self): if hasattr(self, '_m_has_field_combat_template'): return self._m_has_field_combat_template self._m_has_field_combat_template = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_combat_template', None) @property def has_field_move_refresh_ground_force_up(self): if hasattr(self, '_m_has_field_move_refresh_ground_force_up'): return self._m_has_field_move_refresh_ground_force_up self._m_has_field_move_refresh_ground_force_up = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_move_refresh_ground_force_up', None) @property def has_field_has_model(self): if hasattr(self, '_m_has_field_has_model'): return self._m_has_field_has_model self._m_has_field_has_model = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_has_model', None) @property def has_field_connect_trigger_priority(self): if hasattr(self, '_m_has_field_connect_trigger_priority'): return self._m_has_field_connect_trigger_priority self._m_has_field_connect_trigger_priority = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_connect_trigger_priority', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def has_field_camera_box(self): if hasattr(self, '_m_has_field_camera_box'): return self._m_has_field_camera_box self._m_has_field_camera_box = (self.bit_field.value & 2251799813685248) != 0 return getattr(self, '_m_has_field_camera_box', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def has_field_gv_turn(self): if hasattr(self, '_m_has_field_gv_turn'): return self._m_has_field_gv_turn self._m_has_field_gv_turn = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_gv_turn', None) @property def has_field_field(self): if hasattr(self, '_m_has_field_field'): return self._m_has_field_field self._m_has_field_field = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_field', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_combat(self): if hasattr(self, '_m_has_field_combat'): return self._m_has_field_combat self._m_has_field_combat = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_combat', None) @property def has_field_vehicle(self): if hasattr(self, '_m_has_field_vehicle'): return self._m_has_field_vehicle self._m_has_field_vehicle = (self.bit_field.value & 17592186044416) != 0 return getattr(self, '_m_has_field_vehicle', None) @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = (self.bit_field.value & 4398046511104) != 0 return getattr(self, '_m_has_field_tags', None) @property def has_field_dangerzone(self): if hasattr(self, '_m_has_field_dangerzone'): return self._m_has_field_dangerzone self._m_has_field_dangerzone = (self.bit_field.value & 35184372088832) != 0 return getattr(self, '_m_has_field_dangerzone', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_audio', None) @property def has_field_abilities(self): if hasattr(self, '_m_has_field_abilities'): return self._m_has_field_abilities self._m_has_field_abilities = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_abilities', None) @property def has_field_navigation(self): if hasattr(self, '_m_has_field_navigation'): return self._m_has_field_navigation self._m_has_field_navigation = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_navigation', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def has_field_force_set_entity_type(self): if hasattr(self, '_m_has_field_force_set_entity_type'): return self._m_has_field_force_set_entity_type self._m_has_field_force_set_entity_type = (self.bit_field.value & 140737488355328) != 0 return getattr(self, '_m_has_field_force_set_entity_type', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def has_field_ray_tag(self): if hasattr(self, '_m_has_field_ray_tag'): return self._m_has_field_ray_tag self._m_has_field_ray_tag = (self.bit_field.value & 9007199254740992) != 0 return getattr(self, '_m_has_field_ray_tag', None) @property def has_field_dont_destroy_by_perform(self): if hasattr(self, '_m_has_field_dont_destroy_by_perform'): return self._m_has_field_dont_destroy_by_perform self._m_has_field_dont_destroy_by_perform = (self.bit_field.value & 72057594037927936) != 0 return getattr(self, '_m_has_field_dont_destroy_by_perform', None) @property def has_field_can_be_triggered_by_avatar_ray(self): if hasattr(self, '_m_has_field_can_be_triggered_by_avatar_ray'): return self._m_has_field_can_be_triggered_by_avatar_ray self._m_has_field_can_be_triggered_by_avatar_ray = (self.bit_field.value & 8796093022208) != 0 return getattr(self, '_m_has_field_can_be_triggered_by_avatar_ray', None) @property def has_field_move(self): if hasattr(self, '_m_has_field_move'): return self._m_has_field_move self._m_has_field_move = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_move', None) @property def has_field_has_dither(self): if hasattr(self, '_m_has_field_has_dither'): return self._m_has_field_has_dither self._m_has_field_has_dither = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_has_dither', None) @property def has_field_projector(self): if hasattr(self, '_m_has_field_projector'): return self._m_has_field_projector self._m_has_field_projector = (self.bit_field.value & 549755813888) != 0 return getattr(self, '_m_has_field_projector', None) @property def has_field_can_remove_by_client(self): if hasattr(self, '_m_has_field_can_remove_by_client'): return self._m_has_field_can_remove_by_client self._m_has_field_can_remove_by_client = (self.bit_field.value & 2199023255552) != 0 return getattr(self, '_m_has_field_can_remove_by_client', None) @property def has_field_billboard(self): if hasattr(self, '_m_has_field_billboard'): return self._m_has_field_billboard self._m_has_field_billboard = (self.bit_field.value & 68719476736) != 0 return getattr(self, '_m_has_field_billboard', None) @property def has_field_vod_player(self): if hasattr(self, '_m_has_field_vod_player'): return self._m_has_field_vod_player self._m_has_field_vod_player = (self.bit_field.value & 1125899906842624) != 0 return getattr(self, '_m_has_field_vod_player', None) @property def has_field_ui_interact(self): if hasattr(self, '_m_has_field_ui_interact'): return self._m_has_field_ui_interact self._m_has_field_ui_interact = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_ui_interact', None) @property def has_field_use_retreat_type(self): if hasattr(self, '_m_has_field_use_retreat_type'): return self._m_has_field_use_retreat_type self._m_has_field_use_retreat_type = (self.bit_field.value & 36028797018963968) != 0 return getattr(self, '_m_has_field_use_retreat_type', None) @property def has_field_has_audio(self): if hasattr(self, '_m_has_field_has_audio'): return self._m_has_field_has_audio self._m_has_field_has_audio = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_has_audio', None) @property def has_field_gadget_turn(self): if hasattr(self, '_m_has_field_gadget_turn'): return self._m_has_field_gadget_turn self._m_has_field_gadget_turn = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_gadget_turn', None) @property def has_field_state_layers(self): if hasattr(self, '_m_has_field_state_layers'): return self._m_has_field_state_layers self._m_has_field_state_layers = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_state_layers', None) @property def has_field_keep_modifier_out_sight(self): if hasattr(self, '_m_has_field_keep_modifier_out_sight'): return self._m_has_field_keep_modifier_out_sight self._m_has_field_keep_modifier_out_sight = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_keep_modifier_out_sight', None) @property def has_field_low_priority_intee(self): if hasattr(self, '_m_has_field_low_priority_intee'): return self._m_has_field_low_priority_intee self._m_has_field_low_priority_intee = (self.bit_field.value & 1099511627776) != 0 return getattr(self, '_m_has_field_low_priority_intee', None) @property def has_field_radar_hint(self): if hasattr(self, '_m_has_field_radar_hint'): return self._m_has_field_radar_hint self._m_has_field_radar_hint = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_radar_hint', None) @property def has_field_misc(self): if hasattr(self, '_m_has_field_misc'): return self._m_has_field_misc self._m_has_field_misc = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_misc', None) @property def has_field_gadget_action(self): if hasattr(self, '_m_has_field_gadget_action'): return self._m_has_field_gadget_action self._m_has_field_gadget_action = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_gadget_action', None) @property def has_field_paimon(self): if hasattr(self, '_m_has_field_paimon'): return self._m_has_field_paimon self._m_has_field_paimon = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_paimon', None) @property def has_field_weather(self): if hasattr(self, '_m_has_field_weather'): return self._m_has_field_weather self._m_has_field_weather = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_weather', None) @property def has_field_camera_adjust(self): if hasattr(self, '_m_has_field_camera_adjust'): return self._m_has_field_camera_adjust self._m_has_field_camera_adjust = (self.bit_field.value & 281474976710656) != 0 return getattr(self, '_m_has_field_camera_adjust', None) @property def has_field_force_dont_use_update_rigidbody(self): if hasattr(self, '_m_has_field_force_dont_use_update_rigidbody'): return self._m_has_field_force_dont_use_update_rigidbody self._m_has_field_force_dont_use_update_rigidbody = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_force_dont_use_update_rigidbody', None) @property def has_field_aibeta(self): if hasattr(self, '_m_has_field_aibeta'): return self._m_has_field_aibeta self._m_has_field_aibeta = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_aibeta', None) @property def has_field_has_follow_wind_zone_rotation(self): if hasattr(self, '_m_has_field_has_follow_wind_zone_rotation'): return self._m_has_field_has_follow_wind_zone_rotation self._m_has_field_has_follow_wind_zone_rotation = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_has_follow_wind_zone_rotation', None) @property def has_field_ignore_child_scene_prop(self): if hasattr(self, '_m_has_field_ignore_child_scene_prop'): return self._m_has_field_ignore_child_scene_prop self._m_has_field_ignore_child_scene_prop = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_ignore_child_scene_prop', None) @property def has_field_timer(self): if hasattr(self, '_m_has_field_timer'): return self._m_has_field_timer self._m_has_field_timer = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_timer', None) @property def has_field_bind_emotions(self): if hasattr(self, '_m_has_field_bind_emotions'): return self._m_has_field_bind_emotions self._m_has_field_bind_emotions = (self.bit_field.value & 274877906944) != 0 return getattr(self, '_m_has_field_bind_emotions', None) @property def has_field_wall(self): if hasattr(self, '_m_has_field_wall'): return self._m_has_field_wall self._m_has_field_wall = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_wall', None) @property def has_field_has_equip(self): if hasattr(self, '_m_has_field_has_equip'): return self._m_has_field_has_equip self._m_has_field_has_equip = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_has_equip', None) @property def has_field_has_ability(self): if hasattr(self, '_m_has_field_has_ability'): return self._m_has_field_has_ability self._m_has_field_has_ability = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_has_ability', None) @property def has_field_can_be_created_on_platform(self): if hasattr(self, '_m_has_field_can_be_created_on_platform'): return self._m_has_field_can_be_created_on_platform self._m_has_field_can_be_created_on_platform = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_can_be_created_on_platform', None) @property def has_field_has_ray_tag(self): if hasattr(self, '_m_has_field_has_ray_tag'): return self._m_has_field_has_ray_tag self._m_has_field_has_ray_tag = (self.bit_field.value & 18014398509481984) != 0 return getattr(self, '_m_has_field_has_ray_tag', None) @property def has_field_equipment(self): if hasattr(self, '_m_has_field_equipment'): return self._m_has_field_equipment self._m_has_field_equipment = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_equipment', None) @property def has_field_intee(self): if hasattr(self, '_m_has_field_intee'): return self._m_has_field_intee self._m_has_field_intee = (self.bit_field.value & 137438953472) != 0 return getattr(self, '_m_has_field_intee', None) @property def has_field_fishing_zone(self): if hasattr(self, '_m_has_field_fishing_zone'): return self._m_has_field_fishing_zone self._m_has_field_fishing_zone = (self.bit_field.value & 70368744177664) != 0 return getattr(self, '_m_has_field_fishing_zone', None) @property def has_field_part_control(self): if hasattr(self, '_m_has_field_part_control'): return self._m_has_field_part_control self._m_has_field_part_control = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_part_control', None) class ArrayOfBusChannelConfigLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BusChannelConfig(self._io, self, self._root)) class TauntLevelTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWorldAreaLayout(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level1areas: self.level1areas = Output.ArrayOfConfigLevel1worldAreaLengthU(self._io, self, self._root) @property def has_field_level1areas(self): if hasattr(self, '_m_has_field_level1areas'): return self._m_has_field_level1areas self._m_has_field_level1areas = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level1areas', None) class BillboardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfWeaponPropertyLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.WeaponProperty(self._io, self, self._root)) class EnumQteActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteActionType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiBuddyScoring(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hp_factor: self.hp_factor = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_hp_weight: self.hp_weight = self._io.read_f4le() if self.has_field_dist_factor: self.dist_factor = self._io.read_f4le() if self.has_field_dist_weight: self.dist_weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_role_scores: self.role_scores = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_hp_weight(self): if hasattr(self, '_m_has_field_hp_weight'): return self._m_has_field_hp_weight self._m_has_field_hp_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hp_weight', None) @property def has_field_hp_factor(self): if hasattr(self, '_m_has_field_hp_factor'): return self._m_has_field_hp_factor self._m_has_field_hp_factor = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hp_factor', None) @property def has_field_dist_weight(self): if hasattr(self, '_m_has_field_dist_weight'): return self._m_has_field_dist_weight self._m_has_field_dist_weight = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_dist_weight', None) @property def has_field_role_scores(self): if hasattr(self, '_m_has_field_role_scores'): return self._m_has_field_role_scores self._m_has_field_role_scores = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_role_scores', None) @property def has_field_dist_factor(self): if hasattr(self, '_m_has_field_dist_factor'): return self._m_has_field_dist_factor self._m_has_field_dist_factor = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dist_factor', None) class ConfigHomeGather(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_home_gather_id: self.home_gather_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bundle_id: self.bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_home_gather_id(self): if hasattr(self, '_m_has_field_home_gather_id'): return self._m_has_field_home_gather_id self._m_has_field_home_gather_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_home_gather_id', None) @property def has_field_bundle_id(self): if hasattr(self, '_m_has_field_bundle_id'): return self._m_has_field_bundle_id self._m_has_field_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_bundle_id', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_weight', None) class ConfigCapture(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_capture_effect: self.capture_effect = AuxTypes.String(self._io, self, self._root) @property def has_field_capture_effect(self): if hasattr(self, '_m_has_field_capture_effect'): return self._m_has_field_capture_effect self._m_has_field_capture_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_capture_effect', None) class EnumBanType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BanType, self.data.value) return getattr(self, '_m_value', None) class QuestGuideEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumQuestGuideType(self._io, self, self._root) if self.has_field_auto_guide: self.auto_guide = Output.EnumQuestGuideAuto(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_guide_scene: self.guide_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_style: self.guide_style = Output.EnumQuestGuideStyle(self._io, self, self._root) if self.has_field_guide_layer: self.guide_layer = Output.EnumQuestGuideLayer(self._io, self, self._root) @property def has_field_guide_layer(self): if hasattr(self, '_m_has_field_guide_layer'): return self._m_has_field_guide_layer self._m_has_field_guide_layer = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_guide_layer', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param', None) @property def has_field_guide_style(self): if hasattr(self, '_m_has_field_guide_style'): return self._m_has_field_guide_style self._m_has_field_guide_style = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_guide_style', None) @property def has_field_auto_guide(self): if hasattr(self, '_m_has_field_auto_guide'): return self._m_has_field_auto_guide self._m_has_field_auto_guide = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_auto_guide', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_guide_scene(self): if hasattr(self, '_m_has_field_guide_scene'): return self._m_has_field_guide_scene self._m_has_field_guide_scene = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_guide_scene', None) class ConfigTriggerMassiveElementTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityTask(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entity_elements: self.entity_elements = Output.ArrayOfConfigMassiveEntityElementLengthU(self._io, self, self._root) if self.has_field_element_trigger_actions: self.element_trigger_actions = Output.ArrayOfConfigMassiveElementTriggerActionLengthU(self._io, self, self._root) @property def is_async(self): if hasattr(self, '_m_is_async'): return self._m_is_async self._m_is_async = self.base.is_async return getattr(self, '_m_is_async', None) @property def has_field_entity_elements(self): if hasattr(self, '_m_has_field_entity_elements'): return self._m_has_field_entity_elements self._m_has_field_entity_elements = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_elements', None) @property def has_field_element_trigger_actions(self): if hasattr(self, '_m_has_field_element_trigger_actions'): return self._m_has_field_element_trigger_actions self._m_has_field_element_trigger_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_trigger_actions', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ConfigLocalTriggerMetaTeleportV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLocalTriggerMeta(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_curtain_type: self.curtain_type = Output.EnumCurtainType(self._io, self, self._root) @property def has_field_curtain_type(self): if hasattr(self, '_m_has_field_curtain_type'): return self._m_has_field_curtain_type self._m_has_field_curtain_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_curtain_type', None) @property def vector_param(self): if hasattr(self, '_m_vector_param'): return self._m_vector_param self._m_vector_param = self.base.vector_param return getattr(self, '_m_vector_param', None) @property def float_param(self): if hasattr(self, '_m_float_param'): return self._m_float_param self._m_float_param = self.base.float_param return getattr(self, '_m_float_param', None) @property def string_param(self): if hasattr(self, '_m_string_param'): return self._m_string_param self._m_string_param = self.base.string_param return getattr(self, '_m_string_param', None) class PersonalLineActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelMonsterUnit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_inst_id: self.map_inst_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spawned_by_evt_pattern: self.spawned_by_evt_pattern = self._io.read_u1() if self.has_field_route_id: self.route_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ai_patrol_setting: self.ai_patrol_setting = Output.ConfigLevelMonsterAiPatrol(self._io, self, self._root) if self.has_field_ai_group_id: self.ai_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_override_defend_area_range: self.override_defend_area_range = self._io.read_u1() if self.has_field_defend_area_range: self.defend_area_range = self._io.read_f4le() if self.has_field_override_force_alert_distance: self.override_force_alert_distance = self._io.read_u1() if self.has_field_force_alert_distance_limit: self.force_alert_distance_limit = self._io.read_f4le() if self.has_field_defend_area_id: self.defend_area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_wander_area_id: self.wander_area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_override_clear_threat_target_distance: self.override_clear_threat_target_distance = self._io.read_u1() if self.has_field_clear_threat_target_distance: self.clear_threat_target_distance = self._io.read_f4le() if self.has_field_ai_neuron_setting: self.ai_neuron_setting = AuxTypes.String(self._io, self, self._root) if self.has_field_ai_sensing_template: self.ai_sensing_template = AuxTypes.String(self._io, self, self._root) if self.has_field_force_combat_on_spawn: self.force_combat_on_spawn = self._io.read_u1() if self.has_field_disable_wander: self.disable_wander = self._io.read_u1() if self.has_field_stand_on_distant_mesh: self.stand_on_distant_mesh = self._io.read_u1() if self.has_field_landing_point_id: self.landing_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extraction_point_id: self.extraction_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_override_use_navmesh: self.override_use_navmesh = self._io.read_u1() if self.has_field_use_navmesh: self.use_navmesh = self._io.read_u1() if self.has_field_billboard_has_ui_bar: self.billboard_has_ui_bar = self._io.read_u1() if self.has_field_billboard_show_ui_bar_dis: self.billboard_show_ui_bar_dis = self._io.read_f4le() if self.has_field_billboard_hide_ui_bar_dis: self.billboard_hide_ui_bar_dis = self._io.read_f4le() if self.has_field_billboard_ui_bar_need_enter_combat: self.billboard_ui_bar_need_enter_combat = self._io.read_u1() if self.has_field_billboard_hp_bar_style: self.billboard_hp_bar_style = Output.EnumHpBarStyle(self._io, self, self._root) if self.has_field_billboard_multi_bar_sort_id: self.billboard_multi_bar_sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_billboard_multi_bar_num: self.billboard_multi_bar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reuse_not_remove_ability_tag: self.reuse_not_remove_ability_tag = AuxTypes.String(self._io, self, self._root) @property def has_field_wander_area_id(self): if hasattr(self, '_m_has_field_wander_area_id'): return self._m_has_field_wander_area_id self._m_has_field_wander_area_id = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_wander_area_id', None) @property def has_field_spawned_by_evt_pattern(self): if hasattr(self, '_m_has_field_spawned_by_evt_pattern'): return self._m_has_field_spawned_by_evt_pattern self._m_has_field_spawned_by_evt_pattern = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_spawned_by_evt_pattern', None) @property def has_field_route_id(self): if hasattr(self, '_m_has_field_route_id'): return self._m_has_field_route_id self._m_has_field_route_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_route_id', None) @property def has_field_billboard_multi_bar_num(self): if hasattr(self, '_m_has_field_billboard_multi_bar_num'): return self._m_has_field_billboard_multi_bar_num self._m_has_field_billboard_multi_bar_num = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_billboard_multi_bar_num', None) @property def has_field_billboard_show_ui_bar_dis(self): if hasattr(self, '_m_has_field_billboard_show_ui_bar_dis'): return self._m_has_field_billboard_show_ui_bar_dis self._m_has_field_billboard_show_ui_bar_dis = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_billboard_show_ui_bar_dis', None) @property def has_field_billboard_hide_ui_bar_dis(self): if hasattr(self, '_m_has_field_billboard_hide_ui_bar_dis'): return self._m_has_field_billboard_hide_ui_bar_dis self._m_has_field_billboard_hide_ui_bar_dis = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_billboard_hide_ui_bar_dis', None) @property def has_field_billboard_has_ui_bar(self): if hasattr(self, '_m_has_field_billboard_has_ui_bar'): return self._m_has_field_billboard_has_ui_bar self._m_has_field_billboard_has_ui_bar = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_billboard_has_ui_bar', None) @property def has_field_force_combat_on_spawn(self): if hasattr(self, '_m_has_field_force_combat_on_spawn'): return self._m_has_field_force_combat_on_spawn self._m_has_field_force_combat_on_spawn = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_force_combat_on_spawn', None) @property def has_field_override_clear_threat_target_distance(self): if hasattr(self, '_m_has_field_override_clear_threat_target_distance'): return self._m_has_field_override_clear_threat_target_distance self._m_has_field_override_clear_threat_target_distance = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_override_clear_threat_target_distance', None) @property def has_field_landing_point_id(self): if hasattr(self, '_m_has_field_landing_point_id'): return self._m_has_field_landing_point_id self._m_has_field_landing_point_id = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_landing_point_id', None) @property def has_field_ai_patrol_setting(self): if hasattr(self, '_m_has_field_ai_patrol_setting'): return self._m_has_field_ai_patrol_setting self._m_has_field_ai_patrol_setting = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_ai_patrol_setting', None) @property def has_field_defend_area_id(self): if hasattr(self, '_m_has_field_defend_area_id'): return self._m_has_field_defend_area_id self._m_has_field_defend_area_id = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_defend_area_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_billboard_multi_bar_sort_id(self): if hasattr(self, '_m_has_field_billboard_multi_bar_sort_id'): return self._m_has_field_billboard_multi_bar_sort_id self._m_has_field_billboard_multi_bar_sort_id = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_billboard_multi_bar_sort_id', None) @property def has_field_stand_on_distant_mesh(self): if hasattr(self, '_m_has_field_stand_on_distant_mesh'): return self._m_has_field_stand_on_distant_mesh self._m_has_field_stand_on_distant_mesh = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_stand_on_distant_mesh', None) @property def has_field_ai_group_id(self): if hasattr(self, '_m_has_field_ai_group_id'): return self._m_has_field_ai_group_id self._m_has_field_ai_group_id = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_ai_group_id', None) @property def has_field_ai_sensing_template(self): if hasattr(self, '_m_has_field_ai_sensing_template'): return self._m_has_field_ai_sensing_template self._m_has_field_ai_sensing_template = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_ai_sensing_template', None) @property def has_field_extraction_point_id(self): if hasattr(self, '_m_has_field_extraction_point_id'): return self._m_has_field_extraction_point_id self._m_has_field_extraction_point_id = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_extraction_point_id', None) @property def has_field_defend_area_range(self): if hasattr(self, '_m_has_field_defend_area_range'): return self._m_has_field_defend_area_range self._m_has_field_defend_area_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_defend_area_range', None) @property def has_field_use_navmesh(self): if hasattr(self, '_m_has_field_use_navmesh'): return self._m_has_field_use_navmesh self._m_has_field_use_navmesh = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_use_navmesh', None) @property def has_field_clear_threat_target_distance(self): if hasattr(self, '_m_has_field_clear_threat_target_distance'): return self._m_has_field_clear_threat_target_distance self._m_has_field_clear_threat_target_distance = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_clear_threat_target_distance', None) @property def has_field_billboard_hp_bar_style(self): if hasattr(self, '_m_has_field_billboard_hp_bar_style'): return self._m_has_field_billboard_hp_bar_style self._m_has_field_billboard_hp_bar_style = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_billboard_hp_bar_style', None) @property def has_field_override_defend_area_range(self): if hasattr(self, '_m_has_field_override_defend_area_range'): return self._m_has_field_override_defend_area_range self._m_has_field_override_defend_area_range = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_override_defend_area_range', None) @property def has_field_reuse_not_remove_ability_tag(self): if hasattr(self, '_m_has_field_reuse_not_remove_ability_tag'): return self._m_has_field_reuse_not_remove_ability_tag self._m_has_field_reuse_not_remove_ability_tag = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_reuse_not_remove_ability_tag', None) @property def has_field_override_force_alert_distance(self): if hasattr(self, '_m_has_field_override_force_alert_distance'): return self._m_has_field_override_force_alert_distance self._m_has_field_override_force_alert_distance = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_override_force_alert_distance', None) @property def has_field_disable_wander(self): if hasattr(self, '_m_has_field_disable_wander'): return self._m_has_field_disable_wander self._m_has_field_disable_wander = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_disable_wander', None) @property def has_field_ai_neuron_setting(self): if hasattr(self, '_m_has_field_ai_neuron_setting'): return self._m_has_field_ai_neuron_setting self._m_has_field_ai_neuron_setting = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_ai_neuron_setting', None) @property def has_field_map_inst_id(self): if hasattr(self, '_m_has_field_map_inst_id'): return self._m_has_field_map_inst_id self._m_has_field_map_inst_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_map_inst_id', None) @property def has_field_override_use_navmesh(self): if hasattr(self, '_m_has_field_override_use_navmesh'): return self._m_has_field_override_use_navmesh self._m_has_field_override_use_navmesh = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_override_use_navmesh', None) @property def has_field_billboard_ui_bar_need_enter_combat(self): if hasattr(self, '_m_has_field_billboard_ui_bar_need_enter_combat'): return self._m_has_field_billboard_ui_bar_need_enter_combat self._m_has_field_billboard_ui_bar_need_enter_combat = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_billboard_ui_bar_need_enter_combat', None) @property def has_field_force_alert_distance_limit(self): if hasattr(self, '_m_has_field_force_alert_distance_limit'): return self._m_has_field_force_alert_distance_limit self._m_has_field_force_alert_distance_limit = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_force_alert_distance_limit', None) class PerceptionTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_view_range_factor: self.view_range_factor = self._io.read_f4le() if self.has_field_feel_range_factor: self.feel_range_factor = self._io.read_f4le() if self.has_field_hear_footstep_range_factor: self.hear_footstep_range_factor = self._io.read_f4le() if self.has_field_hear_other_range_factor: self.hear_other_range_factor = self._io.read_f4le() @property def has_field_feel_range_factor(self): if hasattr(self, '_m_has_field_feel_range_factor'): return self._m_has_field_feel_range_factor self._m_has_field_feel_range_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_feel_range_factor', None) @property def has_field_hear_footstep_range_factor(self): if hasattr(self, '_m_has_field_hear_footstep_range_factor'): return self._m_has_field_hear_footstep_range_factor self._m_has_field_hear_footstep_range_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hear_footstep_range_factor', None) @property def has_field_hear_other_range_factor(self): if hasattr(self, '_m_has_field_hear_other_range_factor'): return self._m_has_field_hear_other_range_factor self._m_has_field_hear_other_range_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_hear_other_range_factor', None) @property def has_field_view_range_factor(self): if hasattr(self, '_m_has_field_view_range_factor'): return self._m_has_field_view_range_factor self._m_has_field_view_range_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_view_range_factor', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class RigidBodyFreezeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class SceneAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFireworksReformSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FireworksReformSkillType, self.data.value) return getattr(self, '_m_value', None) class AudioTreeDataAssetNamePattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pattern: self.pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_pattern(self): if hasattr(self, '_m_has_field_pattern'): return self._m_has_field_pattern self._m_has_field_pattern = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_pattern', None) class EnumAntialiasingMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AntialiasingMethod, self.data.value) return getattr(self, '_m_value', None) class ByTargetLayoutArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_area_type: self.area_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_area_type(self): if hasattr(self, '_m_has_field_area_type'): return self._m_has_field_area_type self._m_has_field_area_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_type', None) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_area_id', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigPerfBoolItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfU1LengthU(self._io, self, self._root) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class EnumTextParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TextParamType, self.data.value) return getattr(self, '_m_value', None) class ExcelConfigUtil(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumAbilityStateArrayOfEnumElementReactionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumAbilityState(self._io, self, self._root) self.value = Output.ArrayOfEnumElementReactionTypeLengthU(self._io, self, self._root) class InvestigationDungeonConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_entrance_id: self.entrance_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id_list: self.dungeon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_entrance_id(self): if hasattr(self, '_m_has_field_entrance_id'): return self._m_has_field_entrance_id self._m_has_field_entrance_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_entrance_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_dungeon_id_list(self): if hasattr(self, '_m_has_field_dungeon_id_list'): return self._m_has_field_dungeon_id_list self._m_has_field_dungeon_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_id_list', None) class LevelTagResetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExpeditionActivityMarkerExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos_x: self.pos_x = self._io.read_f4le() if self.has_field_pos_y: self.pos_y = self._io.read_f4le() if self.has_field_picture_hash: self.picture_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_picture_hash: self.picture_hash_pre = self._io.read_s1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_pos_x(self): if hasattr(self, '_m_has_field_pos_x'): return self._m_has_field_pos_x self._m_has_field_pos_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pos_x', None) @property def has_field_pos_y(self): if hasattr(self, '_m_has_field_pos_y'): return self._m_has_field_pos_y self._m_has_field_pos_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pos_y', None) @property def has_field_picture_hash(self): if hasattr(self, '_m_has_field_picture_hash'): return self._m_has_field_picture_hash self._m_has_field_picture_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_picture_hash', None) class EffigyLimitingConditionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_type: self.condition_type = Output.EnumEffigyCondition(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_condition_param1: self.condition_param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_param2: self.condition_param2 = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exclusive_id: self.exclusive_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_in_row: self.is_in_row = self._io.read_u1() if self.has_field_exclusive_desc: self.exclusive_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_exclusive_desc(self): if hasattr(self, '_m_has_field_exclusive_desc'): return self._m_has_field_exclusive_desc self._m_has_field_exclusive_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_exclusive_desc', None) @property def has_field_exclusive_id(self): if hasattr(self, '_m_has_field_exclusive_id'): return self._m_has_field_exclusive_id self._m_has_field_exclusive_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_exclusive_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_condition_type(self): if hasattr(self, '_m_has_field_condition_type'): return self._m_has_field_condition_type self._m_has_field_condition_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_condition_type', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_condition_param2(self): if hasattr(self, '_m_has_field_condition_param2'): return self._m_has_field_condition_param2 self._m_has_field_condition_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_condition_param2', None) @property def has_field_condition_param1(self): if hasattr(self, '_m_has_field_condition_param1'): return self._m_has_field_condition_param1 self._m_has_field_condition_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_condition_param1', None) @property def has_field_is_in_row(self): if hasattr(self, '_m_has_field_is_in_row'): return self._m_has_field_is_in_row self._m_has_field_is_in_row = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_in_row', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigPredicateByInteract(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_enable_interact: self.is_enable_interact = self._io.read_u1() @property def has_field_is_enable_interact(self): if hasattr(self, '_m_has_field_is_enable_interact'): return self._m_has_field_is_enable_interact self._m_has_field_is_enable_interact = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_enable_interact', None) class EnumMoveToType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoveToType, self.data.value) return getattr(self, '_m_value', None) class GadgetPropExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hp: self.hp = self._io.read_f4le() if self.has_field_hp_curve: self.hp_curve = Output.EnumGrowCurveType(self._io, self, self._root) if self.has_field_attack: self.attack = self._io.read_f4le() if self.has_field_attack_curve: self.attack_curve = Output.EnumGrowCurveType(self._io, self, self._root) if self.has_field_defense: self.defense = self._io.read_f4le() if self.has_field_defense_curve: self.defense_curve = Output.EnumGrowCurveType(self._io, self, self._root) @property def has_field_attack(self): if hasattr(self, '_m_has_field_attack'): return self._m_has_field_attack self._m_has_field_attack = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_attack', None) @property def has_field_attack_curve(self): if hasattr(self, '_m_has_field_attack_curve'): return self._m_has_field_attack_curve self._m_has_field_attack_curve = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_attack_curve', None) @property def has_field_hp_curve(self): if hasattr(self, '_m_has_field_hp_curve'): return self._m_has_field_hp_curve self._m_has_field_hp_curve = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_hp_curve', None) @property def has_field_defense_curve(self): if hasattr(self, '_m_has_field_defense_curve'): return self._m_has_field_defense_curve self._m_has_field_defense_curve = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_defense_curve', None) @property def has_field_defense(self): if hasattr(self, '_m_has_field_defense'): return self._m_has_field_defense self._m_has_field_defense = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_defense', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hp(self): if hasattr(self, '_m_has_field_hp'): return self._m_has_field_hp self._m_has_field_hp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hp', None) class MonsterLaunchMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_motion_change: self.on_motion_change = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_run_up_to_pos: self.run_up_to_pos = AuxTypes.String(self._io, self, self._root) if self.has_field_launch_to_pos: self.launch_to_pos = AuxTypes.String(self._io, self, self._root) if self.has_field_launch_speed_bezier_type: self.launch_speed_bezier_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_has_launch_pos: self.has_launch_pos = self._io.read_u1() if self.has_field_launch_time: self.launch_time = self._io.read_f4le() if self.has_field_launch_speed: self.launch_speed = self._io.read_f4le() @property def has_field_launch_speed(self): if hasattr(self, '_m_has_field_launch_speed'): return self._m_has_field_launch_speed self._m_has_field_launch_speed = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_launch_speed', None) @property def has_field_launch_to_pos(self): if hasattr(self, '_m_has_field_launch_to_pos'): return self._m_has_field_launch_to_pos self._m_has_field_launch_to_pos = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_launch_to_pos', None) @property def has_field_launch_speed_bezier_type(self): if hasattr(self, '_m_has_field_launch_speed_bezier_type'): return self._m_has_field_launch_speed_bezier_type self._m_has_field_launch_speed_bezier_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_launch_speed_bezier_type', None) @property def has_field_launch_time(self): if hasattr(self, '_m_has_field_launch_time'): return self._m_has_field_launch_time self._m_has_field_launch_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_launch_time', None) @property def has_field_run_up_to_pos(self): if hasattr(self, '_m_has_field_run_up_to_pos'): return self._m_has_field_run_up_to_pos self._m_has_field_run_up_to_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_run_up_to_pos', None) @property def has_field_has_launch_pos(self): if hasattr(self, '_m_has_field_has_launch_pos'): return self._m_has_field_has_launch_pos self._m_has_field_has_launch_pos = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_has_launch_pos', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_on_motion_change(self): if hasattr(self, '_m_has_field_on_motion_change'): return self._m_has_field_on_motion_change self._m_has_field_on_motion_change = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_motion_change', None) class EnumGuideTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideTriggerType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumFadeTintQualityLevelConfigTintFadeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumFadeTintQualityLevel(self._io, self, self._root) self.value = Output.ConfigTintFadeSetting(self._io, self, self._root) class DirectionAngleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumWatcherPredicateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WatcherPredicateType, self.data.value) return getattr(self, '_m_value', None) class HuntingClueMonsterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level_id: self.revise_level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_type: self.group_type = Output.EnumHuntingMonsterGroupType(self._io, self, self._root) if self.has_field_monster_group_id: self.monster_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_clue_monster: self.is_clue_monster = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_revise_level_id(self): if hasattr(self, '_m_has_field_revise_level_id'): return self._m_has_field_revise_level_id self._m_has_field_revise_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_revise_level_id', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_is_clue_monster(self): if hasattr(self, '_m_has_field_is_clue_monster'): return self._m_has_field_is_clue_monster self._m_has_field_is_clue_monster = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_clue_monster', None) @property def has_field_monster_group_id(self): if hasattr(self, '_m_has_field_monster_group_id'): return self._m_has_field_monster_group_id self._m_has_field_monster_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_group_id', None) @property def has_field_group_type(self): if hasattr(self, '_m_has_field_group_type'): return self._m_has_field_group_type self._m_has_field_group_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_type', None) class EntityAttackFilterComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FishRodExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByItemNumber(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_num: self.item_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def has_field_item_num(self): if hasattr(self, '_m_has_field_item_num'): return self._m_has_field_item_num self._m_has_field_item_num = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_num', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MechanicusCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetKeepInAirVelocityForce(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumTreeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TreeType, self.data.value) return getattr(self, '_m_value', None) class EnableAvatarMoveOnWater(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigGadgetConsole(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_in_trigger_ability_name: self.in_trigger_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_out_trigger_ability_name: self.out_trigger_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_reminder_text_map: self.reminder_text_map = AuxTypes.String(self._io, self, self._root) if self.has_field_reminder_vanish_delay: self.reminder_vanish_delay = self._io.read_f4le() if self.has_field_camera_attach_point: self.camera_attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_finish_gadget_state: self.finish_gadget_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_operations: self.operations = Output.ArrayOfConfigGadgetConsoleOperationLengthU(self._io, self, self._root) if self.has_field_limitations: self.limitations = Output.ArrayOfConfigGadgetConsoleLimitationLengthU(self._io, self, self._root) if self.has_field_finish_position: self.finish_position = Output.ArrayOfConfigGadgetConsolePositionLengthU(self._io, self, self._root) @property def has_field_limitations(self): if hasattr(self, '_m_has_field_limitations'): return self._m_has_field_limitations self._m_has_field_limitations = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_limitations', None) @property def has_field_operations(self): if hasattr(self, '_m_has_field_operations'): return self._m_has_field_operations self._m_has_field_operations = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_operations', None) @property def has_field_reminder_text_map(self): if hasattr(self, '_m_has_field_reminder_text_map'): return self._m_has_field_reminder_text_map self._m_has_field_reminder_text_map = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_reminder_text_map', None) @property def has_field_out_trigger_ability_name(self): if hasattr(self, '_m_has_field_out_trigger_ability_name'): return self._m_has_field_out_trigger_ability_name self._m_has_field_out_trigger_ability_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_out_trigger_ability_name', None) @property def has_field_finish_position(self): if hasattr(self, '_m_has_field_finish_position'): return self._m_has_field_finish_position self._m_has_field_finish_position = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_finish_position', None) @property def has_field_finish_gadget_state(self): if hasattr(self, '_m_has_field_finish_gadget_state'): return self._m_has_field_finish_gadget_state self._m_has_field_finish_gadget_state = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_finish_gadget_state', None) @property def has_field_in_trigger_ability_name(self): if hasattr(self, '_m_has_field_in_trigger_ability_name'): return self._m_has_field_in_trigger_ability_name self._m_has_field_in_trigger_ability_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_in_trigger_ability_name', None) @property def has_field_camera_attach_point(self): if hasattr(self, '_m_has_field_camera_attach_point'): return self._m_has_field_camera_attach_point self._m_has_field_camera_attach_point = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_camera_attach_point', None) @property def has_field_reminder_vanish_delay(self): if hasattr(self, '_m_has_field_reminder_vanish_delay'): return self._m_has_field_reminder_vanish_delay self._m_has_field_reminder_vanish_delay = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_reminder_vanish_delay', None) class ChessCardTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoutineActionypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByCurTeamHasElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class LanV2projectionStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TransPointUpdateMaterial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mat_path: self.mat_path = AuxTypes.String(self._io, self, self._root) if self.has_field_transforms: self.transforms = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_mat_path(self): if hasattr(self, '_m_has_field_mat_path'): return self._m_has_field_mat_path self._m_has_field_mat_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mat_path', None) @property def has_field_transforms(self): if hasattr(self, '_m_has_field_transforms'): return self._m_has_field_transforms self._m_has_field_transforms = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_transforms', None) class EnumGadgetUiItemGroupShowCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetUiItemGroupShowCondType, self.data.value) return getattr(self, '_m_value', None) class CustomGadgetRootTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAnimationBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class GetInteractIdToGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EntityTokenActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSpatialRoom(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_reverb_aux_bus: self.reverb_aux_bus = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_reverb_level: self.reverb_level = self._io.read_f4le() if self.has_field_wall_occlusion: self.wall_occlusion = self._io.read_f4le() if self.has_field_aux_send_level_to_self: self.aux_send_level_to_self = self._io.read_f4le() if self.has_field_keep_register: self.keep_register = self._io.read_u1() if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_major_room: self.is_major_room = self._io.read_u1() if self.has_field_box_room_triggers: self.box_room_triggers = Output.ArrayOfConfigSpatialBoxRoomTriggerLengthU(self._io, self, self._root) if self.has_field_sphere_room_triggers: self.sphere_room_triggers = Output.ArrayOfConfigSpatialSphereRoomTriggerLengthU(self._io, self, self._root) @property def has_field_reverb_level(self): if hasattr(self, '_m_has_field_reverb_level'): return self._m_has_field_reverb_level self._m_has_field_reverb_level = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_reverb_level', None) @property def has_field_is_major_room(self): if hasattr(self, '_m_has_field_is_major_room'): return self._m_has_field_is_major_room self._m_has_field_is_major_room = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_is_major_room', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_wall_occlusion(self): if hasattr(self, '_m_has_field_wall_occlusion'): return self._m_has_field_wall_occlusion self._m_has_field_wall_occlusion = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_wall_occlusion', None) @property def has_field_keep_register(self): if hasattr(self, '_m_has_field_keep_register'): return self._m_has_field_keep_register self._m_has_field_keep_register = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_keep_register', None) @property def has_field_reverb_aux_bus(self): if hasattr(self, '_m_has_field_reverb_aux_bus'): return self._m_has_field_reverb_aux_bus self._m_has_field_reverb_aux_bus = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_reverb_aux_bus', None) @property def has_field_sphere_room_triggers(self): if hasattr(self, '_m_has_field_sphere_room_triggers'): return self._m_has_field_sphere_room_triggers self._m_has_field_sphere_room_triggers = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_sphere_room_triggers', None) @property def has_field_box_room_triggers(self): if hasattr(self, '_m_has_field_box_room_triggers'): return self._m_has_field_box_room_triggers self._m_has_field_box_room_triggers = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_box_room_triggers', None) @property def has_field_aux_send_level_to_self(self): if hasattr(self, '_m_has_field_aux_send_level_to_self'): return self._m_has_field_aux_send_level_to_self self._m_has_field_aux_send_level_to_self = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_aux_send_level_to_self', None) class ConfigQteStepBaseAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_action_type: self.action_type = Output.EnumQteStepActionType(self._io, self, self._root) if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_type', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) class ConfigWidgetToyGadgetBuilder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height_to_avatar: self.height_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_check_collision: self.check_collision = self._io.read_u1() @property def has_field_height_to_avatar(self): if hasattr(self, '_m_has_field_height_to_avatar'): return self._m_has_field_height_to_avatar self._m_has_field_height_to_avatar = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_height_to_avatar', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_check_collision(self): if hasattr(self, '_m_has_field_check_collision'): return self._m_has_field_check_collision self._m_has_field_check_collision = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_check_collision', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class EntityPropPerMpConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_prop_value_vec: self.prop_value_vec = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prop_type', None) @property def has_field_prop_value_vec(self): if hasattr(self, '_m_has_field_prop_value_vec'): return self._m_has_field_prop_value_vec self._m_has_field_prop_value_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prop_value_vec', None) class ConfigCombatSpeech(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_head_shot_speech_event: self.head_shot_speech_event = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_head_shot_speech_event(self): if hasattr(self, '_m_has_field_head_shot_speech_event'): return self._m_has_field_head_shot_speech_event self._m_has_field_head_shot_speech_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_head_shot_speech_event', None) class ConfigAttackAttenuation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_reset_cycle: self.reset_cycle = self._io.read_f4le() if self.has_field_durability_sequence: self.durability_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_enbreak_sequence: self.enbreak_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_damage_sequence: self.damage_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_reset_cycle(self): if hasattr(self, '_m_has_field_reset_cycle'): return self._m_has_field_reset_cycle self._m_has_field_reset_cycle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reset_cycle', None) @property def has_field_durability_sequence(self): if hasattr(self, '_m_has_field_durability_sequence'): return self._m_has_field_durability_sequence self._m_has_field_durability_sequence = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_durability_sequence', None) @property def has_field_enbreak_sequence(self): if hasattr(self, '_m_has_field_enbreak_sequence'): return self._m_has_field_enbreak_sequence self._m_has_field_enbreak_sequence = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enbreak_sequence', None) @property def has_field_damage_sequence(self): if hasattr(self, '_m_has_field_damage_sequence'): return self._m_has_field_damage_sequence self._m_has_field_damage_sequence = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_damage_sequence', None) class ArrayOfSingleTargetLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SingleTarget(self._io, self, self._root)) class KvpOfDictAuxTypesStringConfigAbilityPropertyEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAbilityPropertyEntry(self._io, self, self._root) class HomeWorldCustomFurnitureSlotExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumMarkOrderAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumMarkOrder(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class KeyboardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShareCdExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cool_down_list: self.cool_down_list = Output.ArrayOfCoolDownInfoLengthS(self._io, self, self._root) if self.has_field_is_use_real_time: self.is_use_real_time = self._io.read_u1() if self.has_field_is_use_external_system: self.is_use_external_system = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_cool_down_list(self): if hasattr(self, '_m_has_field_cool_down_list'): return self._m_has_field_cool_down_list self._m_has_field_cool_down_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cool_down_list', None) @property def has_field_is_use_real_time(self): if hasattr(self, '_m_has_field_is_use_real_time'): return self._m_has_field_is_use_real_time self._m_has_field_is_use_real_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_use_real_time', None) @property def has_field_is_use_external_system(self): if hasattr(self, '_m_has_field_is_use_external_system'): return self._m_has_field_is_use_external_system self._m_has_field_is_use_external_system = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_use_external_system', None) class KvpOfDictAuxTypesStringAudioPlatformSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.AudioPlatformSetting(self._io, self, self._root) class AudioWeatherWorkSet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_state_group_name: self.state_group_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_activeness_rtpc_name: self.activeness_rtpc_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_workset_switch_value: self.workset_switch_value = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_state_group_name(self): if hasattr(self, '_m_has_field_state_group_name'): return self._m_has_field_state_group_name self._m_has_field_state_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_group_name', None) @property def has_field_activeness_rtpc_name(self): if hasattr(self, '_m_has_field_activeness_rtpc_name'): return self._m_has_field_activeness_rtpc_name self._m_has_field_activeness_rtpc_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_activeness_rtpc_name', None) @property def has_field_workset_switch_value(self): if hasattr(self, '_m_has_field_workset_switch_value'): return self._m_has_field_workset_switch_value self._m_has_field_workset_switch_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_workset_switch_value', None) class PerfItemValueTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBaseGuide(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDialogSelectAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_talk_id_list: self.talk_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dialog_id_list: self.dialog_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_grp_id_list: self.grp_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_use_grp_id: self.use_grp_id = self._io.read_u1() @property def has_field_dialog_id_list(self): if hasattr(self, '_m_has_field_dialog_id_list'): return self._m_has_field_dialog_id_list self._m_has_field_dialog_id_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dialog_id_list', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_grp_id_list(self): if hasattr(self, '_m_has_field_grp_id_list'): return self._m_has_field_grp_id_list self._m_has_field_grp_id_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_grp_id_list', None) @property def has_field_talk_id_list(self): if hasattr(self, '_m_has_field_talk_id_list'): return self._m_has_field_talk_id_list self._m_has_field_talk_id_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_id_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_use_grp_id(self): if hasattr(self, '_m_has_field_use_grp_id'): return self._m_has_field_use_grp_id self._m_has_field_use_grp_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_grp_id', None) class ConfigRecordRagdollParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_prefab_hash: self.prefab_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_velocity_on_root: self.velocity_on_root = Output.Vector(self._io, self, self._root) if self.has_field_explosion_force: self.explosion_force = Output.Vector(self._io, self, self._root) @property def has_field_prefab_hash(self): if hasattr(self, '_m_has_field_prefab_hash'): return self._m_has_field_prefab_hash self._m_has_field_prefab_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_prefab_hash', None) @property def has_field_velocity_on_root(self): if hasattr(self, '_m_has_field_velocity_on_root'): return self._m_has_field_velocity_on_root self._m_has_field_velocity_on_root = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_velocity_on_root', None) @property def has_field_explosion_force(self): if hasattr(self, '_m_has_field_explosion_force'): return self._m_has_field_explosion_force self._m_has_field_explosion_force = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_explosion_force', None) class PlayEmojiBubble(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigEffectLod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_use_distance_lod_entity_types: self.use_distance_lod_entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) @property def has_field_use_distance_lod_entity_types(self): if hasattr(self, '_m_has_field_use_distance_lod_entity_types'): return self._m_has_field_use_distance_lod_entity_types self._m_has_field_use_distance_lod_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_distance_lod_entity_types', None) class ParamLogicTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSafeTypeReportData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_count: self.max_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_max_count(self): if hasattr(self, '_m_has_field_max_count'): return self._m_has_field_max_count self._m_has_field_max_count = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_count', None) class SetAiSkillGcd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigCameraShakeAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shake_range: self.shake_range = self._io.read_f4le() if self.has_field_shake_time: self.shake_time = self._io.read_f4le() if self.has_field_shake_dinstance: self.shake_dinstance = self._io.read_f4le() if self.has_field_shake_dir: self.shake_dir = Output.Vector(self._io, self, self._root) @property def has_field_shake_range(self): if hasattr(self, '_m_has_field_shake_range'): return self._m_has_field_shake_range self._m_has_field_shake_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shake_range', None) @property def has_field_shake_dinstance(self): if hasattr(self, '_m_has_field_shake_dinstance'): return self._m_has_field_shake_dinstance self._m_has_field_shake_dinstance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_shake_dinstance', None) @property def has_field_shake_time(self): if hasattr(self, '_m_has_field_shake_time'): return self._m_has_field_shake_time self._m_has_field_shake_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shake_time', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_shake_dir(self): if hasattr(self, '_m_has_field_shake_dir'): return self._m_has_field_shake_dir self._m_has_field_shake_dir = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_shake_dir', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class TriggerElementSupportMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TriggerTypeSupportMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def radius(self): if hasattr(self, '_m_radius'): return self._m_radius self._m_radius = self.base.radius return getattr(self, '_m_radius', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class CombatEndCleanExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlessingScanPicExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grant_reward_cost: self.grant_reward_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_grant_reward_cost(self): if hasattr(self, '_m_has_field_grant_reward_cost'): return self._m_has_field_grant_reward_cost self._m_has_field_grant_reward_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_grant_reward_cost', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_name', None) class ModifySkillCost(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_delta: self.cost_delta = self._io.read_f4le() if self.has_field_cost_ratio: self.cost_ratio = self._io.read_f4le() @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_cost_delta(self): if hasattr(self, '_m_has_field_cost_delta'): return self._m_has_field_cost_delta self._m_has_field_cost_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cost_delta', None) @property def has_field_cost_ratio(self): if hasattr(self, '_m_has_field_cost_ratio'): return self._m_has_field_cost_ratio self._m_has_field_cost_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cost_ratio', None) class EmojiSetDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) class RandTaskRewardConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TokenJsonPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_op: self.op = Output.EnumLogicOperation(self._io, self, self._root) if self.has_field_inherit_from: self.inherit_from = AuxTypes.String(self._io, self, self._root) if self.has_field_has_properties: self.has_properties = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_paths: self.paths = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_children: self.children = Output.ArrayOfTokenJsonPathLengthU(self._io, self, self._root) @property def has_field_has_properties(self): if hasattr(self, '_m_has_field_has_properties'): return self._m_has_field_has_properties self._m_has_field_has_properties = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_has_properties', None) @property def has_field_paths(self): if hasattr(self, '_m_has_field_paths'): return self._m_has_field_paths self._m_has_field_paths = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_paths', None) @property def has_field_children(self): if hasattr(self, '_m_has_field_children'): return self._m_has_field_children self._m_has_field_children = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_children', None) @property def has_field_op(self): if hasattr(self, '_m_has_field_op'): return self._m_has_field_op self._m_has_field_op = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_op', None) @property def has_field_inherit_from(self): if hasattr(self, '_m_has_field_inherit_from'): return self._m_has_field_inherit_from self._m_has_field_inherit_from = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_inherit_from', None) class ConfigGadgetStateEnableAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class RoomExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_nav_mesh_path: self.nav_mesh_path = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prefab_path', None) @property def has_field_nav_mesh_path(self): if hasattr(self, '_m_has_field_nav_mesh_path'): return self._m_has_field_nav_mesh_path self._m_has_field_nav_mesh_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_nav_mesh_path', None) class StreamingModifierMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_apply_modifier: self.apply_modifier = self._io.read_u1() @property def has_field_apply_modifier(self): if hasattr(self, '_m_has_field_apply_modifier'): return self._m_has_field_apply_modifier self._m_has_field_apply_modifier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_apply_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class IrodoriExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForceUseSkillSuccess(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumUseSkillType(self._io, self, self._root) if self.has_field_immediately: self.immediately = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_immediately(self): if hasattr(self, '_m_has_field_immediately'): return self._m_has_field_immediately self._m_has_field_immediately = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_immediately', None) class BySkillReady(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_slot: self.skill_slot = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_skill_slot(self): if hasattr(self, '_m_has_field_skill_slot'): return self._m_has_field_skill_slot self._m_has_field_skill_slot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_slot', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class KvpOfDictAuxTypesStringConfigAttackAttenuation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAttackAttenuation(self._io, self, self._root) class KvpOfDictEnumConfigAiCombatPhaseArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumConfigAiCombatPhase(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) class DragonSpineMissionFinishConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDragonSpineMissionFinishExecType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class CameraSetReflectionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_reflection_layer: self.reflection_layer = AuxTypes.String(self._io, self, self._root) if self.has_field_reflection_plane_trans_name: self.reflection_plane_trans_name = AuxTypes.String(self._io, self, self._root) @property def has_field_reflection_layer(self): if hasattr(self, '_m_has_field_reflection_layer'): return self._m_has_field_reflection_layer self._m_has_field_reflection_layer = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reflection_layer', None) @property def has_field_reflection_plane_trans_name(self): if hasattr(self, '_m_has_field_reflection_plane_trans_name'): return self._m_has_field_reflection_plane_trans_name self._m_has_field_reflection_plane_trans_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reflection_plane_trans_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class LocalGadgetCmdExeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigLocalTriggerMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigLocalTriggerMeta(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLocalTriggerMetaTeleportV2(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class AddClimateMeter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DailyTaskFinishTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableWetElectricHitBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enabled: self.enabled = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_enabled(self): if hasattr(self, '_m_has_field_enabled'): return self._m_has_field_enabled self._m_has_field_enabled = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enabled', None) class RefreshIndexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRefreshIndexType(self._io, self, self._root) if self.has_field_rarity: self.rarity = Output.EnumMonsterRarityType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_refresh_id: self.refresh_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_rarity(self): if hasattr(self, '_m_has_field_rarity'): return self._m_has_field_rarity self._m_has_field_rarity = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rarity', None) @property def has_field_refresh_id(self): if hasattr(self, '_m_has_field_refresh_id'): return self._m_has_field_refresh_id self._m_has_field_refresh_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_refresh_id', None) class LongIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumSceneSurfaceTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumSceneSurfaceType(self._io, self, self._root)) class ElementBatchPredicated(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type_arr: self.element_type_arr = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_success_actions: self.success_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_element_type_arr(self): if hasattr(self, '_m_has_field_element_type_arr'): return self._m_has_field_element_type_arr self._m_has_field_element_type_arr = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type_arr', None) @property def has_field_success_actions(self): if hasattr(self, '_m_has_field_success_actions'): return self._m_has_field_success_actions self._m_has_field_success_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_success_actions', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fail_actions', None) class GrassQualityLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeatherTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFleeData(self._io, self, self._root)) class EnumGroupIoType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GroupIoType, self.data.value) return getattr(self, '_m_value', None) class SumoDifficultyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumIrodoriMasterLevelType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriMasterLevelType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfRoutineActionContentLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RoutineActionContent(self._io, self, self._root)) class WidgetSkillStart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigGadgetStateSetAnimTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_id: self.trigger_id = AuxTypes.String(self._io, self, self._root) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_id', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class QuestSummarizationTextExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAttackSphere(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSimpleAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_detect_direction: self.detect_direction = Output.EnumSphereDetectDirection(self._io, self, self._root) @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def use_custom_shape(self): if hasattr(self, '_m_use_custom_shape'): return self._m_use_custom_shape self._m_use_custom_shape = self.base.use_custom_shape return getattr(self, '_m_use_custom_shape', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def has_field_detect_direction(self): if hasattr(self, '_m_has_field_detect_direction'): return self._m_has_field_detect_direction self._m_has_field_detect_direction = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_direction', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFacingMoveData(self._io, self, self._root) class ConfigAiMixinActions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_set_pose_bool: self.set_pose_bool = Output.ArrayOfConfigAiMixinSetBoolLengthU(self._io, self, self._root) if self.has_field_set_pose_int: self.set_pose_int = Output.ArrayOfConfigAiMixinSetIntLengthU(self._io, self, self._root) if self.has_field_set_pose_float: self.set_pose_float = Output.ArrayOfConfigAiMixinSetFloatLengthU(self._io, self, self._root) if self.has_field_set_animator_trigger: self.set_animator_trigger = Output.ArrayOfConfigAiMixinSetAnimatorTriggerLengthU(self._io, self, self._root) if self.has_field_set_animator_bool: self.set_animator_bool = Output.ArrayOfConfigAiMixinSetBoolLengthU(self._io, self, self._root) if self.has_field_set_animator_int: self.set_animator_int = Output.ArrayOfConfigAiMixinSetIntLengthU(self._io, self, self._root) if self.has_field_set_animator_float: self.set_animator_float = Output.ArrayOfConfigAiMixinSetFloatLengthU(self._io, self, self._root) @property def has_field_set_animator_trigger(self): if hasattr(self, '_m_has_field_set_animator_trigger'): return self._m_has_field_set_animator_trigger self._m_has_field_set_animator_trigger = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_set_animator_trigger', None) @property def has_field_set_animator_float(self): if hasattr(self, '_m_has_field_set_animator_float'): return self._m_has_field_set_animator_float self._m_has_field_set_animator_float = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_set_animator_float', None) @property def has_field_set_animator_bool(self): if hasattr(self, '_m_has_field_set_animator_bool'): return self._m_has_field_set_animator_bool self._m_has_field_set_animator_bool = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_set_animator_bool', None) @property def has_field_set_pose_int(self): if hasattr(self, '_m_has_field_set_pose_int'): return self._m_has_field_set_pose_int self._m_has_field_set_pose_int = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_pose_int', None) @property def has_field_set_pose_bool(self): if hasattr(self, '_m_has_field_set_pose_bool'): return self._m_has_field_set_pose_bool self._m_has_field_set_pose_bool = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_pose_bool', None) @property def has_field_set_pose_float(self): if hasattr(self, '_m_has_field_set_pose_float'): return self._m_has_field_set_pose_float self._m_has_field_set_pose_float = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_pose_float', None) @property def has_field_set_animator_int(self): if hasattr(self, '_m_has_field_set_animator_int'): return self._m_has_field_set_animator_int self._m_has_field_set_animator_int = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_set_animator_int', None) class DispConfigEffectAttachShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigEffectAttachShape(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigEffectAttachBox(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigEffectAttachMesh(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigEffectAttachSkinnedMesh(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DispConfigBattleFervorUpdatePredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBattleFervorUpdatePredicate(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBattleFervorUpdatePredicateFactorRange(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBattleFervorUpdatePredicateLocalAvatarInBattle(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DraftExecSubTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GatherBundleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumNewActivityCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ConfigJudgeAvatarConfigId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_i_ds: self.config_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_config_i_ds(self): if hasattr(self, '_m_has_field_config_i_ds'): return self._m_has_field_config_i_ds self._m_has_field_config_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_i_ds', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class InvestigationMonsterMapMarkCreateConditionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUConfigCoopInteractionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigCoopInteractionGroup(self._io, self, self._root) class EnumActorEvtTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActorEvtTargetType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiFleeOnBlockAvatarLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFleeOnBlockAvatarLandingData(self._io, self, self._root) class AttackAttenuationExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group: self.group = AuxTypes.String(self._io, self, self._root) if self.has_field_reset_cycle: self.reset_cycle = self._io.read_f4le() if self.has_field_durability_sequence: self.durability_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_enbreak_sequence: self.enbreak_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_damage_sequence: self.damage_sequence = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_group(self): if hasattr(self, '_m_has_field_group'): return self._m_has_field_group self._m_has_field_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group', None) @property def has_field_damage_sequence(self): if hasattr(self, '_m_has_field_damage_sequence'): return self._m_has_field_damage_sequence self._m_has_field_damage_sequence = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_damage_sequence', None) @property def has_field_durability_sequence(self): if hasattr(self, '_m_has_field_durability_sequence'): return self._m_has_field_durability_sequence self._m_has_field_durability_sequence = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_durability_sequence', None) @property def has_field_enbreak_sequence(self): if hasattr(self, '_m_has_field_enbreak_sequence'): return self._m_has_field_enbreak_sequence self._m_has_field_enbreak_sequence = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_enbreak_sequence', None) @property def has_field_reset_cycle(self): if hasattr(self, '_m_has_field_reset_cycle'): return self._m_has_field_reset_cycle self._m_has_field_reset_cycle = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reset_cycle', None) class ReviseLevelGrowExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grade: self.grade = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_grade(self): if hasattr(self, '_m_has_field_grade'): return self._m_has_field_grade self._m_has_field_grade = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_grade', None) class ClearPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class WidgetCdSyncMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_sync_on_tick: self.sync_on_tick = self._io.read_u1() if self.has_field_sync_on_change_avatar: self.sync_on_change_avatar = self._io.read_u1() if self.has_field_sync_on_cd_change: self.sync_on_cd_change = self._io.read_u1() if self.has_field_sync_only_greater: self.sync_only_greater = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_cd_offset: self.skill_cd_offset = self._io.read_f4le() @property def has_field_sync_on_cd_change(self): if hasattr(self, '_m_has_field_sync_on_cd_change'): return self._m_has_field_sync_on_cd_change self._m_has_field_sync_on_cd_change = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sync_on_cd_change', None) @property def has_field_sync_on_change_avatar(self): if hasattr(self, '_m_has_field_sync_on_change_avatar'): return self._m_has_field_sync_on_change_avatar self._m_has_field_sync_on_change_avatar = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sync_on_change_avatar', None) @property def has_field_skill_cd_offset(self): if hasattr(self, '_m_has_field_skill_cd_offset'): return self._m_has_field_skill_cd_offset self._m_has_field_skill_cd_offset = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_skill_cd_offset', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_sync_on_tick(self): if hasattr(self, '_m_has_field_sync_on_tick'): return self._m_has_field_sync_on_tick self._m_has_field_sync_on_tick = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sync_on_tick', None) @property def has_field_sync_only_greater(self): if hasattr(self, '_m_has_field_sync_only_greater'): return self._m_has_field_sync_only_greater self._m_has_field_sync_only_greater = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_sync_only_greater', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_item_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class SeaLampSectionMiniQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetLunchBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_revive_materials: self.revive_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_heal_materials: self.heal_materials = Output.ConfigWidgetLunchBoxHealMaterial(self._io, self, self._root) @property def has_field_revive_materials(self): if hasattr(self, '_m_has_field_revive_materials'): return self._m_has_field_revive_materials self._m_has_field_revive_materials = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_revive_materials', None) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def has_field_heal_materials(self): if hasattr(self, '_m_has_field_heal_materials'): return self._m_has_field_heal_materials self._m_has_field_heal_materials = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_heal_materials', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class EnumBartenderMixingState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BartenderMixingState, self.data.value) return getattr(self, '_m_value', None) class WinterCampRaceItemTipsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) class KvpOfDictAuxTypesStringConfigSceneArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigSceneArea(self._io, self, self._root) class UseSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicSingleEqualityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigCodexQuestSubQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sub_quest_title: self.sub_quest_title = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_items: self.items = Output.ArrayOfConfigCodexQuestItemLengthU(self._io, self, self._root) @property def has_field_sub_quest_title(self): if hasattr(self, '_m_has_field_sub_quest_title'): return self._m_has_field_sub_quest_title self._m_has_field_sub_quest_title = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sub_quest_title', None) @property def has_field_items(self): if hasattr(self, '_m_has_field_items'): return self._m_has_field_items self._m_has_field_items = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_items', None) class ArrayOfConfigAbilityStateToActionsLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAbilityStateToActions(self._io, self, self._root)) class ProductMcoinDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_item_name: self.item_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prim_name: self.prim_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_mcoin_num: self.mcoin_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mcoin_non_first: self.mcoin_non_first = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mcoin_first: self.mcoin_first = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_seqence: self.seqence = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_mcoin_non_first(self): if hasattr(self, '_m_has_field_mcoin_non_first'): return self._m_has_field_mcoin_non_first self._m_has_field_mcoin_non_first = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mcoin_non_first', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_seqence(self): if hasattr(self, '_m_has_field_seqence'): return self._m_has_field_seqence self._m_has_field_seqence = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_seqence', None) @property def has_field_mcoin_first(self): if hasattr(self, '_m_has_field_mcoin_first'): return self._m_has_field_mcoin_first self._m_has_field_mcoin_first = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_mcoin_first', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_mcoin_num(self): if hasattr(self, '_m_has_field_mcoin_num'): return self._m_has_field_mcoin_num self._m_has_field_mcoin_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_mcoin_num', None) @property def has_field_item_name(self): if hasattr(self, '_m_has_field_item_name'): return self._m_has_field_item_name self._m_has_field_item_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_item_name', None) @property def has_field_prim_name(self): if hasattr(self, '_m_has_field_prim_name'): return self._m_has_field_prim_name self._m_has_field_prim_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prim_name', None) class DoTileActionManagerMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_action_id: self.action_id = AuxTypes.String(self._io, self, self._root) if self.has_field_action_pos_key: self.action_pos_key = AuxTypes.String(self._io, self, self._root) if self.has_field_action_radius_key: self.action_radius_key = AuxTypes.String(self._io, self, self._root) if self.has_field_reaction_force_use_owner_prop: self.reaction_force_use_owner_prop = self._io.read_u1() if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_action_radius_key(self): if hasattr(self, '_m_has_field_action_radius_key'): return self._m_has_field_action_radius_key self._m_has_field_action_radius_key = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_action_radius_key', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_action_id(self): if hasattr(self, '_m_has_field_action_id'): return self._m_has_field_action_id self._m_has_field_action_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_id', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_action_pos_key(self): if hasattr(self, '_m_has_field_action_pos_key'): return self._m_has_field_action_pos_key self._m_has_field_action_pos_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_action_pos_key', None) @property def has_field_reaction_force_use_owner_prop(self): if hasattr(self, '_m_has_field_reaction_force_use_owner_prop'): return self._m_has_field_reaction_force_use_owner_prop self._m_has_field_reaction_force_use_owner_prop = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_reaction_force_use_owner_prop', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class UidOpNotifyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_content', None) class ModifyElementDecrateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group: self.group = AuxTypes.String(self._io, self, self._root) @property def has_field_group(self): if hasattr(self, '_m_has_field_group'): return self._m_has_field_group self._m_has_field_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WidgetCameraExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PsActivitiesActivityConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachModifierToSelfGlobalValueMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_target: self.global_value_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_add_action: self.add_action = Output.EnumAddActionType(self._io, self, self._root) if self.has_field_default_global_value_on_create: self.default_global_value_on_create = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_action_queues: self.action_queues = Output.ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(self._io, self, self._root) if self.has_field_remove_applied_modifier: self.remove_applied_modifier = self._io.read_u1() @property def has_field_default_global_value_on_create(self): if hasattr(self, '_m_has_field_default_global_value_on_create'): return self._m_has_field_default_global_value_on_create self._m_has_field_default_global_value_on_create = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_global_value_on_create', None) @property def has_field_action_queues(self): if hasattr(self, '_m_has_field_action_queues'): return self._m_has_field_action_queues self._m_has_field_action_queues = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_action_queues', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_global_value_target(self): if hasattr(self, '_m_has_field_global_value_target'): return self._m_has_field_global_value_target self._m_has_field_global_value_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_target', None) @property def has_field_add_action(self): if hasattr(self, '_m_has_field_add_action'): return self._m_has_field_add_action self._m_has_field_add_action = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_add_action', None) @property def has_field_remove_applied_modifier(self): if hasattr(self, '_m_has_field_remove_applied_modifier'): return self._m_has_field_remove_applied_modifier self._m_has_field_remove_applied_modifier = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_remove_applied_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class EnumActivityMichiaeInteractType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityMichiaeInteractType, self.data.value) return getattr(self, '_m_value', None) class EnumQteStepCameraPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepCameraPosType, self.data.value) return getattr(self, '_m_value', None) class EnumSteerAttackTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SteerAttackTargetType, self.data.value) return getattr(self, '_m_value', None) class CustomLevelTagConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_title: self.tag_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default: self.is_default = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_tag_title(self): if hasattr(self, '_m_has_field_tag_title'): return self._m_has_field_tag_title self._m_has_field_tag_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tag_title', None) @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort_id', None) @property def has_field_is_default(self): if hasattr(self, '_m_has_field_is_default'): return self._m_has_field_is_default self._m_has_field_is_default = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_default', None) class ConfigBattleFervorGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_weight: self.weight = self._io.read_f4le() if self.has_field_factors: self.factors = Output.ArrayOfDispConfigBattleFervorFactorLengthU(self._io, self, self._root) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_factors(self): if hasattr(self, '_m_has_field_factors'): return self._m_has_field_factors self._m_has_field_factors = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_factors', None) class SectrLayerGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_group_name_hash: self.group_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_layer_infos: self.layer_infos = Output.ArrayOfSectrStreamLayerLengthU(self._io, self, self._root) @property def has_field_group_name_hash(self): if hasattr(self, '_m_has_field_group_name_hash'): return self._m_has_field_group_name_hash self._m_has_field_group_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_name_hash', None) @property def has_field_layer_infos(self): if hasattr(self, '_m_has_field_layer_infos'): return self._m_has_field_layer_infos self._m_has_field_layer_infos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_layer_infos', None) class ConfigClimateArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_bottom: self.bottom = self._io.read_f4le() if self.has_field_top: self.top = self._io.read_f4le() if self.has_field_points: self.points = Output.ArrayOfPoint2dLengthU(self._io, self, self._root) if self.has_field_is_force_clear_different_climate_meter: self.is_force_clear_different_climate_meter = self._io.read_u1() if self.has_field_trans_points: self.trans_points = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_bottom(self): if hasattr(self, '_m_has_field_bottom'): return self._m_has_field_bottom self._m_has_field_bottom = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_bottom', None) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def has_field_points(self): if hasattr(self, '_m_has_field_points'): return self._m_has_field_points self._m_has_field_points = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_points', None) @property def has_field_top(self): if hasattr(self, '_m_has_field_top'): return self._m_has_field_top self._m_has_field_top = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_top', None) @property def has_field_is_force_clear_different_climate_meter(self): if hasattr(self, '_m_has_field_is_force_clear_different_climate_meter'): return self._m_has_field_is_force_clear_different_climate_meter self._m_has_field_is_force_clear_different_climate_meter = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_is_force_clear_different_climate_meter', None) @property def has_field_trans_points(self): if hasattr(self, '_m_has_field_trans_points'): return self._m_has_field_trans_points self._m_has_field_trans_points = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_trans_points', None) class ReliquaryMainAffixNameComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumShadowQualityConfigShadowQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumShadowQuality(self._io, self, self._root) self.value = Output.ConfigShadowQualitySetting(self._io, self, self._root) class MailExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_expire_days: self.expire_days = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sender: self.sender = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_star: self.is_star = self._io.read_u1() if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_expire_days(self): if hasattr(self, '_m_has_field_expire_days'): return self._m_has_field_expire_days self._m_has_field_expire_days = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_expire_days', None) @property def has_field_sender(self): if hasattr(self, '_m_has_field_sender'): return self._m_has_field_sender self._m_has_field_sender = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sender', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_is_star(self): if hasattr(self, '_m_has_field_is_star'): return self._m_has_field_is_star self._m_has_field_is_star = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_star', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_content', None) class TweenEaseTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdTextureHash(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_data_q_hash: self.data_q_hash = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_data_t_hash: self.data_t_hash = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_data_q_hash(self): if hasattr(self, '_m_has_field_data_q_hash'): return self._m_has_field_data_q_hash self._m_has_field_data_q_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_data_q_hash', None) @property def has_field_data_t_hash(self): if hasattr(self, '_m_has_field_data_t_hash'): return self._m_has_field_data_t_hash self._m_has_field_data_t_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_data_t_hash', None) class ConfigAiFlySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_floating_poses: self.floating_poses = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_floating_poses(self): if hasattr(self, '_m_has_field_floating_poses'): return self._m_has_field_floating_poses self._m_has_field_floating_poses = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_floating_poses', None) class EnumBlossomRewardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlossomRewardType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiCombatSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TrailData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabLoopDungeonDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigTransPointEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_update_material_list: self.update_material_list = Output.ArrayOfTransPointUpdateMaterialLengthU(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def keep_modifier_out_sight(self): if hasattr(self, '_m_keep_modifier_out_sight'): return self._m_keep_modifier_out_sight self._m_keep_modifier_out_sight = self.base.keep_modifier_out_sight return getattr(self, '_m_keep_modifier_out_sight', None) @property def bind_emotions(self): if hasattr(self, '_m_bind_emotions'): return self._m_bind_emotions self._m_bind_emotions = self.base.bind_emotions return getattr(self, '_m_bind_emotions', None) @property def vod_player(self): if hasattr(self, '_m_vod_player'): return self._m_vod_player self._m_vod_player = self.base.vod_player return getattr(self, '_m_vod_player', None) @property def audio(self): if hasattr(self, '_m_audio'): return self._m_audio self._m_audio = self.base.audio return getattr(self, '_m_audio', None) @property def equipment(self): if hasattr(self, '_m_equipment'): return self._m_equipment self._m_equipment = self.base.equipment return getattr(self, '_m_equipment', None) @property def force_dont_use_update_rigidbody(self): if hasattr(self, '_m_force_dont_use_update_rigidbody'): return self._m_force_dont_use_update_rigidbody self._m_force_dont_use_update_rigidbody = self.base.force_dont_use_update_rigidbody return getattr(self, '_m_force_dont_use_update_rigidbody', None) @property def weather(self): if hasattr(self, '_m_weather'): return self._m_weather self._m_weather = self.base.weather return getattr(self, '_m_weather', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def move(self): if hasattr(self, '_m_move'): return self._m_move self._m_move = self.base.move return getattr(self, '_m_move', None) @property def billboard(self): if hasattr(self, '_m_billboard'): return self._m_billboard self._m_billboard = self.base.billboard return getattr(self, '_m_billboard', None) @property def has_ray_tag(self): if hasattr(self, '_m_has_ray_tag'): return self._m_has_ray_tag self._m_has_ray_tag = self.base.has_ray_tag return getattr(self, '_m_has_ray_tag', None) @property def ray_tag(self): if hasattr(self, '_m_ray_tag'): return self._m_ray_tag self._m_ray_tag = self.base.ray_tag return getattr(self, '_m_ray_tag', None) @property def gadget(self): if hasattr(self, '_m_gadget'): return self._m_gadget self._m_gadget = self.base.gadget return getattr(self, '_m_gadget', None) @property def vehicle(self): if hasattr(self, '_m_vehicle'): return self._m_vehicle self._m_vehicle = self.base.vehicle return getattr(self, '_m_vehicle', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def dont_destroy_by_perform(self): if hasattr(self, '_m_dont_destroy_by_perform'): return self._m_dont_destroy_by_perform self._m_dont_destroy_by_perform = self.base.dont_destroy_by_perform return getattr(self, '_m_dont_destroy_by_perform', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def timer(self): if hasattr(self, '_m_timer'): return self._m_timer self._m_timer = self.base.timer return getattr(self, '_m_timer', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def connect_trigger_priority(self): if hasattr(self, '_m_connect_trigger_priority'): return self._m_connect_trigger_priority self._m_connect_trigger_priority = self.base.connect_trigger_priority return getattr(self, '_m_connect_trigger_priority', None) @property def has_equip(self): if hasattr(self, '_m_has_equip'): return self._m_has_equip self._m_has_equip = self.base.has_equip return getattr(self, '_m_has_equip', None) @property def dangerzone(self): if hasattr(self, '_m_dangerzone'): return self._m_dangerzone self._m_dangerzone = self.base.dangerzone return getattr(self, '_m_dangerzone', None) @property def has_ability(self): if hasattr(self, '_m_has_ability'): return self._m_has_ability self._m_has_ability = self.base.has_ability return getattr(self, '_m_has_ability', None) @property def camera_adjust(self): if hasattr(self, '_m_camera_adjust'): return self._m_camera_adjust self._m_camera_adjust = self.base.camera_adjust return getattr(self, '_m_camera_adjust', None) @property def ignore_child_scene_prop(self): if hasattr(self, '_m_ignore_child_scene_prop'): return self._m_ignore_child_scene_prop self._m_ignore_child_scene_prop = self.base.ignore_child_scene_prop return getattr(self, '_m_ignore_child_scene_prop', None) @property def aibeta(self): if hasattr(self, '_m_aibeta'): return self._m_aibeta self._m_aibeta = self.base.aibeta return getattr(self, '_m_aibeta', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def force_set_entity_type(self): if hasattr(self, '_m_force_set_entity_type'): return self._m_force_set_entity_type self._m_force_set_entity_type = self.base.force_set_entity_type return getattr(self, '_m_force_set_entity_type', None) @property def has_dither(self): if hasattr(self, '_m_has_dither'): return self._m_has_dither self._m_has_dither = self.base.has_dither return getattr(self, '_m_has_dither', None) @property def has_field_update_material_list(self): if hasattr(self, '_m_has_field_update_material_list'): return self._m_has_field_update_material_list self._m_has_field_update_material_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_update_material_list', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def navigation(self): if hasattr(self, '_m_navigation'): return self._m_navigation self._m_navigation = self.base.navigation return getattr(self, '_m_navigation', None) @property def abilities(self): if hasattr(self, '_m_abilities'): return self._m_abilities self._m_abilities = self.base.abilities return getattr(self, '_m_abilities', None) @property def has_follow_wind_zone_rotation(self): if hasattr(self, '_m_has_follow_wind_zone_rotation'): return self._m_has_follow_wind_zone_rotation self._m_has_follow_wind_zone_rotation = self.base.has_follow_wind_zone_rotation return getattr(self, '_m_has_follow_wind_zone_rotation', None) @property def gadget_turn(self): if hasattr(self, '_m_gadget_turn'): return self._m_gadget_turn self._m_gadget_turn = self.base.gadget_turn return getattr(self, '_m_gadget_turn', None) @property def has_audio(self): if hasattr(self, '_m_has_audio'): return self._m_has_audio self._m_has_audio = self.base.has_audio return getattr(self, '_m_has_audio', None) @property def ui_interact(self): if hasattr(self, '_m_ui_interact'): return self._m_ui_interact self._m_ui_interact = self.base.ui_interact return getattr(self, '_m_ui_interact', None) @property def can_be_triggered_by_avatar_ray(self): if hasattr(self, '_m_can_be_triggered_by_avatar_ray'): return self._m_can_be_triggered_by_avatar_ray self._m_can_be_triggered_by_avatar_ray = self.base.can_be_triggered_by_avatar_ray return getattr(self, '_m_can_be_triggered_by_avatar_ray', None) @property def field(self): if hasattr(self, '_m_field'): return self._m_field self._m_field = self.base.field return getattr(self, '_m_field', None) @property def misc(self): if hasattr(self, '_m_misc'): return self._m_misc self._m_misc = self.base.misc return getattr(self, '_m_misc', None) @property def low_priority_intee(self): if hasattr(self, '_m_low_priority_intee'): return self._m_low_priority_intee self._m_low_priority_intee = self.base.low_priority_intee return getattr(self, '_m_low_priority_intee', None) @property def gadget_action(self): if hasattr(self, '_m_gadget_action'): return self._m_gadget_action self._m_gadget_action = self.base.gadget_action return getattr(self, '_m_gadget_action', None) @property def can_remove_by_client(self): if hasattr(self, '_m_can_remove_by_client'): return self._m_can_remove_by_client self._m_can_remove_by_client = self.base.can_remove_by_client return getattr(self, '_m_can_remove_by_client', None) @property def can_be_created_on_platform(self): if hasattr(self, '_m_can_be_created_on_platform'): return self._m_can_be_created_on_platform self._m_can_be_created_on_platform = self.base.can_be_created_on_platform return getattr(self, '_m_can_be_created_on_platform', None) @property def face(self): if hasattr(self, '_m_face'): return self._m_face self._m_face = self.base.face return getattr(self, '_m_face', None) @property def camera_box(self): if hasattr(self, '_m_camera_box'): return self._m_camera_box self._m_camera_box = self.base.camera_box return getattr(self, '_m_camera_box', None) @property def vod_intee(self): if hasattr(self, '_m_vod_intee'): return self._m_vod_intee self._m_vod_intee = self.base.vod_intee return getattr(self, '_m_vod_intee', None) @property def has_connect_trigger(self): if hasattr(self, '_m_has_connect_trigger'): return self._m_has_connect_trigger self._m_has_connect_trigger = self.base.has_connect_trigger return getattr(self, '_m_has_connect_trigger', None) @property def gv_turn(self): if hasattr(self, '_m_gv_turn'): return self._m_gv_turn self._m_gv_turn = self.base.gv_turn return getattr(self, '_m_gv_turn', None) @property def combat_template(self): if hasattr(self, '_m_combat_template'): return self._m_combat_template self._m_combat_template = self.base.combat_template return getattr(self, '_m_combat_template', None) @property def fishing_zone(self): if hasattr(self, '_m_fishing_zone'): return self._m_fishing_zone self._m_fishing_zone = self.base.fishing_zone return getattr(self, '_m_fishing_zone', None) @property def move_refresh_ground_force_up(self): if hasattr(self, '_m_move_refresh_ground_force_up'): return self._m_move_refresh_ground_force_up self._m_move_refresh_ground_force_up = self.base.move_refresh_ground_force_up return getattr(self, '_m_move_refresh_ground_force_up', None) @property def wall(self): if hasattr(self, '_m_wall'): return self._m_wall self._m_wall = self.base.wall return getattr(self, '_m_wall', None) @property def part_control(self): if hasattr(self, '_m_part_control'): return self._m_part_control self._m_part_control = self.base.part_control return getattr(self, '_m_part_control', None) @property def paimon(self): if hasattr(self, '_m_paimon'): return self._m_paimon self._m_paimon = self.base.paimon return getattr(self, '_m_paimon', None) @property def combat(self): if hasattr(self, '_m_combat'): return self._m_combat self._m_combat = self.base.combat return getattr(self, '_m_combat', None) @property def has_model(self): if hasattr(self, '_m_has_model'): return self._m_has_model self._m_has_model = self.base.has_model return getattr(self, '_m_has_model', None) @property def use_retreat_type(self): if hasattr(self, '_m_use_retreat_type'): return self._m_use_retreat_type self._m_use_retreat_type = self.base.use_retreat_type return getattr(self, '_m_use_retreat_type', None) @property def radar_hint(self): if hasattr(self, '_m_radar_hint'): return self._m_radar_hint self._m_radar_hint = self.base.radar_hint return getattr(self, '_m_radar_hint', None) @property def intee(self): if hasattr(self, '_m_intee'): return self._m_intee self._m_intee = self.base.intee return getattr(self, '_m_intee', None) @property def state_layers(self): if hasattr(self, '_m_state_layers'): return self._m_state_layers self._m_state_layers = self.base.state_layers return getattr(self, '_m_state_layers', None) @property def open_watcher(self): if hasattr(self, '_m_open_watcher'): return self._m_open_watcher self._m_open_watcher = self.base.open_watcher return getattr(self, '_m_open_watcher', None) @property def projector(self): if hasattr(self, '_m_projector'): return self._m_projector self._m_projector = self.base.projector return getattr(self, '_m_projector', None) class GadgetPropExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumOptionTypeConfigPostprocessEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumOptionType(self._io, self, self._root) self.value = Output.ConfigPostprocessEffectSetting(self._io, self, self._root) class CityLevelupConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_consume_item: self.consume_item = Output.WorldAreaLevelupConsumeItem(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_vec: self.action_vec = Output.ArrayOfWorldAreaLevelupActionLengthS(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_consume_item(self): if hasattr(self, '_m_has_field_consume_item'): return self._m_has_field_consume_item self._m_has_field_consume_item = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_consume_item', None) @property def has_field_action_vec(self): if hasattr(self, '_m_has_field_action_vec'): return self._m_has_field_action_vec self._m_has_field_action_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_action_vec', None) class CusmtomGadgetSlotExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_slot_type: self.slot_type = Output.EnumCustomGadgetSlotType(self._io, self, self._root) if self.has_field_slot_id: self.slot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_optional_parts_id_list: self.optional_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_necessary: self.is_necessary = self._io.read_u1() if self.has_field_default_parts_id_list: self.default_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pass_part_id_list: self.pass_part_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_parts_id: self.init_parts_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_slot_id(self): if hasattr(self, '_m_has_field_slot_id'): return self._m_has_field_slot_id self._m_has_field_slot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_slot_id', None) @property def has_field_default_parts_id_list(self): if hasattr(self, '_m_has_field_default_parts_id_list'): return self._m_has_field_default_parts_id_list self._m_has_field_default_parts_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_default_parts_id_list', None) @property def has_field_optional_parts_id_list(self): if hasattr(self, '_m_has_field_optional_parts_id_list'): return self._m_has_field_optional_parts_id_list self._m_has_field_optional_parts_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_optional_parts_id_list', None) @property def has_field_slot_type(self): if hasattr(self, '_m_has_field_slot_type'): return self._m_has_field_slot_type self._m_has_field_slot_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_slot_type', None) @property def has_field_init_parts_id(self): if hasattr(self, '_m_has_field_init_parts_id'): return self._m_has_field_init_parts_id self._m_has_field_init_parts_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_init_parts_id', None) @property def has_field_is_necessary(self): if hasattr(self, '_m_has_field_is_necessary'): return self._m_has_field_is_necessary self._m_has_field_is_necessary = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_necessary', None) @property def has_field_pass_part_id_list(self): if hasattr(self, '_m_has_field_pass_part_id_list'): return self._m_has_field_pass_part_id_list self._m_has_field_pass_part_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pass_part_id_list', None) class ConfigAttackUsePrefab(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_prefab_path_name: self.prefab_path_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_connect: self.is_connect = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def has_field_is_connect(self): if hasattr(self, '_m_has_field_is_connect'): return self._m_has_field_is_connect self._m_has_field_is_connect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_connect', None) @property def has_field_prefab_path_name(self): if hasattr(self, '_m_has_field_prefab_path_name'): return self._m_has_field_prefab_path_name self._m_has_field_prefab_path_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_prefab_path_name', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class IrodoriChessMapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_map_id: self.map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entry_point_id: self.entry_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show: self.show = self._io.read_u1() if self.has_field_card_pool: self.card_pool = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_total_card_points: self.total_card_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_gear_limits: self.single_gear_limits = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_entrance_point_list: self.entrance_point_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exit_point_list: self.exit_point_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_disorder_list: self.disorder_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_entry_page_disorder_list: self.entry_page_disorder_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_building_points: self.init_building_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_hard_map: self.is_hard_map = self._io.read_u1() if self.has_field_map_name: self.map_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_icon_path: self.map_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_preset_gear_map: self.preset_gear_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) @property def has_field_entry_point_id(self): if hasattr(self, '_m_has_field_entry_point_id'): return self._m_has_field_entry_point_id self._m_has_field_entry_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_entry_point_id', None) @property def has_field_single_gear_limits(self): if hasattr(self, '_m_has_field_single_gear_limits'): return self._m_has_field_single_gear_limits self._m_has_field_single_gear_limits = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_single_gear_limits', None) @property def has_field_exit_point_list(self): if hasattr(self, '_m_has_field_exit_point_list'): return self._m_has_field_exit_point_list self._m_has_field_exit_point_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_exit_point_list', None) @property def has_field_disorder_list(self): if hasattr(self, '_m_has_field_disorder_list'): return self._m_has_field_disorder_list self._m_has_field_disorder_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_disorder_list', None) @property def has_field_map_id(self): if hasattr(self, '_m_has_field_map_id'): return self._m_has_field_map_id self._m_has_field_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_map_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_map_name(self): if hasattr(self, '_m_has_field_map_name'): return self._m_has_field_map_name self._m_has_field_map_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_map_name', None) @property def has_field_entry_page_disorder_list(self): if hasattr(self, '_m_has_field_entry_page_disorder_list'): return self._m_has_field_entry_page_disorder_list self._m_has_field_entry_page_disorder_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_entry_page_disorder_list', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_show', None) @property def has_field_init_building_points(self): if hasattr(self, '_m_has_field_init_building_points'): return self._m_has_field_init_building_points self._m_has_field_init_building_points = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_init_building_points', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_entrance_point_list(self): if hasattr(self, '_m_has_field_entrance_point_list'): return self._m_has_field_entrance_point_list self._m_has_field_entrance_point_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_entrance_point_list', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_card_pool(self): if hasattr(self, '_m_has_field_card_pool'): return self._m_has_field_card_pool self._m_has_field_card_pool = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_card_pool', None) @property def has_field_is_hard_map(self): if hasattr(self, '_m_has_field_is_hard_map'): return self._m_has_field_is_hard_map self._m_has_field_is_hard_map = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_hard_map', None) @property def has_field_total_card_points(self): if hasattr(self, '_m_has_field_total_card_points'): return self._m_has_field_total_card_points self._m_has_field_total_card_points = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_total_card_points', None) @property def has_field_map_icon_path(self): if hasattr(self, '_m_has_field_map_icon_path'): return self._m_has_field_map_icon_path self._m_has_field_map_icon_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_map_icon_path', None) @property def has_field_preset_gear_map(self): if hasattr(self, '_m_has_field_preset_gear_map'): return self._m_has_field_preset_gear_map self._m_has_field_preset_gear_map = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_preset_gear_map', None) class DailyDungeonConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAttackTrail(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSimpleAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trail_name: self.trail_name = AuxTypes.String(self._io, self, self._root) if self.has_field_trail_start_name: self.trail_start_name = AuxTypes.String(self._io, self, self._root) @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def has_field_trail_name(self): if hasattr(self, '_m_has_field_trail_name'): return self._m_has_field_trail_name self._m_has_field_trail_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trail_name', None) @property def use_custom_shape(self): if hasattr(self, '_m_use_custom_shape'): return self._m_use_custom_shape self._m_use_custom_shape = self.base.use_custom_shape return getattr(self, '_m_use_custom_shape', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def has_field_trail_start_name(self): if hasattr(self, '_m_has_field_trail_start_name'): return self._m_has_field_trail_start_name self._m_has_field_trail_start_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trail_start_name', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class ActivityGachaStageTextExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBattleFervorFormula(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_groups: self.groups = Output.ArrayOfConfigBattleFervorGroupLengthU(self._io, self, self._root) if self.has_field_battle_fervor_min_value: self.battle_fervor_min_value = self._io.read_f4le() if self.has_field_battle_fervor_max_value: self.battle_fervor_max_value = self._io.read_f4le() if self.has_field_battle_fervor_base_value: self.battle_fervor_base_value = self._io.read_f4le() if self.has_field_lerp_interval: self.lerp_interval = self._io.read_f4le() if self.has_field_lerp_coefficient: self.lerp_coefficient = self._io.read_f4le() @property def has_field_lerp_interval(self): if hasattr(self, '_m_has_field_lerp_interval'): return self._m_has_field_lerp_interval self._m_has_field_lerp_interval = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_lerp_interval', None) @property def has_field_battle_fervor_base_value(self): if hasattr(self, '_m_has_field_battle_fervor_base_value'): return self._m_has_field_battle_fervor_base_value self._m_has_field_battle_fervor_base_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_battle_fervor_base_value', None) @property def has_field_battle_fervor_min_value(self): if hasattr(self, '_m_has_field_battle_fervor_min_value'): return self._m_has_field_battle_fervor_min_value self._m_has_field_battle_fervor_min_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_battle_fervor_min_value', None) @property def has_field_battle_fervor_max_value(self): if hasattr(self, '_m_has_field_battle_fervor_max_value'): return self._m_has_field_battle_fervor_max_value self._m_has_field_battle_fervor_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_battle_fervor_max_value', None) @property def has_field_groups(self): if hasattr(self, '_m_has_field_groups'): return self._m_has_field_groups self._m_has_field_groups = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_groups', None) @property def has_field_lerp_coefficient(self): if hasattr(self, '_m_has_field_lerp_coefficient'): return self._m_has_field_lerp_coefficient self._m_has_field_lerp_coefficient = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_lerp_coefficient', None) class ConfigAudioListenerOutreachCast(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_range: self.range = self._io.read_f4le() if self.has_field_start_angle: self.start_angle = self._io.read_f4le() if self.has_field_ray_count: self.ray_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_rtpc_names: self.rtpc_names = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_range', None) @property def has_field_ray_count(self): if hasattr(self, '_m_has_field_ray_count'): return self._m_has_field_ray_count self._m_has_field_ray_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ray_count', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_rtpc_names(self): if hasattr(self, '_m_has_field_rtpc_names'): return self._m_has_field_rtpc_names self._m_has_field_rtpc_names = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_rtpc_names', None) @property def has_field_start_angle(self): if hasattr(self, '_m_has_field_start_angle'): return self._m_has_field_start_angle self._m_has_field_start_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_angle', None) class ByAttackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_type: self.attack_type = Output.EnumAttackType(self._io, self, self._root) @property def has_field_attack_type(self): if hasattr(self, '_m_has_field_attack_type'): return self._m_has_field_attack_type self._m_has_field_attack_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class SetNeuronMute(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_neuron_name: self.neuron_name = Output.EnumNeuronName(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_neuron_name(self): if hasattr(self, '_m_has_field_neuron_name'): return self._m_has_field_neuron_name self._m_has_field_neuron_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_neuron_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DispConfigBaseGuide(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigGuideDelayDoAction(self._io, self, self._root) elif _on == 61: self.data = Output.ConfigGuidePageCheckBaseCondition(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigGuideForceAvatarMoveAction(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigGuideShowPanelAction(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBaseGuide(self._io, self, self._root) elif _on == 47: self.data = Output.ConfigGuideOpenPaimonNavigationCondition(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigGuideShowPage(self._io, self, self._root) elif _on == 42: self.data = Output.ConfigGuideHasAvatarCondition(self._io, self, self._root) elif _on == 46: self.data = Output.ConfigGuideNavigationCondition(self._io, self, self._root) elif _on == 39: self.data = Output.ConfigGuideMultiSinglePlayerCondition(self._io, self, self._root) elif _on == 60: self.data = Output.ConfigGuideMechanicusCurseCardCondition(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigGuideLevelCondition(self._io, self, self._root) elif _on == 35: self.data = Output.ConfigGuideHasItemCondition(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigGuideSetOpenStateAction(self._io, self, self._root) elif _on == 62: self.data = Output.ConfigGuideAnchorUnlockCondition(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigGuideProjectionGameFinishAction(self._io, self, self._root) elif _on == 32: self.data = Output.ConfigGuideTabItemCondition(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigGuideAddTaskAction(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGuideAction(self._io, self, self._root) elif _on == 55: self.data = Output.ConfigGuideSceneIdCondition(self._io, self, self._root) elif _on == 27: self.data = Output.ConfigGuideCanGetPersonalLineKeyCondition(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigGuideAddCmd(self._io, self, self._root) elif _on == 52: self.data = Output.ConfigGuideLevelTypeCondition(self._io, self, self._root) elif _on == 56: self.data = Output.ConfigGuideDungeonIdCondition(self._io, self, self._root) elif _on == 45: self.data = Output.ConfigGuideCheckQuestStateCondition(self._io, self, self._root) elif _on == 66: self.data = Output.ConfigGuideProjectionGameStartCondition(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigGuideCameraControlAction(self._io, self, self._root) elif _on == 67: self.data = Output.ConfigGuideProjectionGameFinishCondition(self._io, self, self._root) elif _on == 69: self.data = Output.ConfigGuideHideandSeekSkillCategoryCondition(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigGuideBanUiAction(self._io, self, self._root) elif _on == 59: self.data = Output.ConfigGuideMechanicusPickCardCondition(self._io, self, self._root) elif _on == 58: self.data = Output.ConfigGuideFoundationBuildCondition(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigGuideUiMaskAction(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigGuideInfoDialogAction(self._io, self, self._root) elif _on == 33: self.data = Output.ConfigGuideTheatreMechanicusBuildingSelectCondition(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigGuideFinishQuestAction(self._io, self, self._root) elif _on == 63: self.data = Output.ConfigGuideFlyStartCondition(self._io, self, self._root) elif _on == 51: self.data = Output.ConfigGuideCheckAimCondition(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigGuideOpenStateCondition(self._io, self, self._root) elif _on == 48: self.data = Output.ConfigGuideVirtualDialActionCondition(self._io, self, self._root) elif _on == 53: self.data = Output.ConfigGuidePressKeyCondition(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigGuideDoActionByPredicate(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigGuideEndTaskAction(self._io, self, self._root) elif _on == 38: self.data = Output.ConfigGuideDelayFinishCondition(self._io, self, self._root) elif _on == 40: self.data = Output.ConfigGuideMultiPlayerCondition(self._io, self, self._root) elif _on == 64: self.data = Output.ConfigGuideFlyFinishCondition(self._io, self, self._root) elif _on == 65: self.data = Output.ConfigGuideFlyFailCondition(self._io, self, self._root) elif _on == 44: self.data = Output.ConfigGuideCheckTaskFinishCondition(self._io, self, self._root) elif _on == 57: self.data = Output.ConfigGuideHomeSceneCondition(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigGuidePauseAction(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigGuideGeneralCondition(self._io, self, self._root) elif _on == 37: self.data = Output.ConfigGuideAvatarActionCondition(self._io, self, self._root) elif _on == 41: self.data = Output.ConfigGuideTeamAvatarNumCondition(self._io, self, self._root) elif _on == 36: self.data = Output.ConfigGuideCameraCondition(self._io, self, self._root) elif _on == 28: self.data = Output.ConfigGuideClimateTypeCondition(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigGuideShowTutorialAction(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigGuideSwitchInputContextAction(self._io, self, self._root) elif _on == 68: self.data = Output.ConfigGuideActivityGachaCondition(self._io, self, self._root) elif _on == 26: self.data = Output.ConfigGuideAvatarChangeCondition(self._io, self, self._root) elif _on == 31: self.data = Output.ConfigGuideButtonClickCondition(self._io, self, self._root) elif _on == 49: self.data = Output.ConfigGuideCenterVirtualDialActionCondition(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigGuideCondition(self._io, self, self._root) elif _on == 34: self.data = Output.ConfigGuideTheatreMechanicusInfoSelectCondition(self._io, self, self._root) elif _on == 54: self.data = Output.ConfigGuideMapClickCondition(self._io, self, self._root) elif _on == 29: self.data = Output.ConfigGuideTeamMemberCondition(self._io, self, self._root) elif _on == 25: self.data = Output.ConfigGuideOpenUiCondition(self._io, self, self._root) elif _on == 43: self.data = Output.ConfigGuideKillMonsterCondition(self._io, self, self._root) elif _on == 50: self.data = Output.ConfigGuideCheckPlatformCondition(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigAvatarEquipChangedCondition(self._io, self, self._root) elif _on == 30: self.data = Output.ConfigGuideAvatarStateCondition(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigVisibleInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_visible: self.is_visible = self._io.read_u1() if self.has_field_use_dither: self.use_dither = self._io.read_u1() if self.has_field_target: self.target = Output.EnumInterActionTargetType(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_use_dither(self): if hasattr(self, '_m_has_field_use_dither'): return self._m_has_field_use_dither self._m_has_field_use_dither = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_dither', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_is_visible(self): if hasattr(self, '_m_has_field_is_visible'): return self._m_has_field_is_visible self._m_has_field_is_visible = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_visible', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigWidgetToyFeather(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_on_radar: self.show_on_radar = self._io.read_u1() if self.has_field_ui_camera_effect: self.ui_camera_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_main_camera_effect: self.main_camera_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_show_hint: self.show_hint = self._io.read_u1() if self.has_field_show_hint_distance: self.show_hint_distance = self._io.read_f4le() if self.has_field_show_hint_entity_id_list: self.show_hint_entity_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_exclude_suite_index: self.exclude_suite_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_team: self.is_team = self._io.read_u1() @property def has_field_show_hint(self): if hasattr(self, '_m_has_field_show_hint'): return self._m_has_field_show_hint self._m_has_field_show_hint = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_show_hint', None) @property def has_field_is_team(self): if hasattr(self, '_m_has_field_is_team'): return self._m_has_field_is_team self._m_has_field_is_team = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_is_team', None) @property def has_field_ui_camera_effect(self): if hasattr(self, '_m_has_field_ui_camera_effect'): return self._m_has_field_ui_camera_effect self._m_has_field_ui_camera_effect = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_ui_camera_effect', None) @property def has_field_show_on_radar(self): if hasattr(self, '_m_has_field_show_on_radar'): return self._m_has_field_show_on_radar self._m_has_field_show_on_radar = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_show_on_radar', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_exclude_suite_index(self): if hasattr(self, '_m_has_field_exclude_suite_index'): return self._m_has_field_exclude_suite_index self._m_has_field_exclude_suite_index = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_exclude_suite_index', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_main_camera_effect(self): if hasattr(self, '_m_has_field_main_camera_effect'): return self._m_has_field_main_camera_effect self._m_has_field_main_camera_effect = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_main_camera_effect', None) @property def has_field_show_hint_entity_id_list(self): if hasattr(self, '_m_has_field_show_hint_entity_id_list'): return self._m_has_field_show_hint_entity_id_list self._m_has_field_show_hint_entity_id_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_hint_entity_id_list', None) @property def has_field_show_hint_distance(self): if hasattr(self, '_m_has_field_show_hint_distance'): return self._m_has_field_show_hint_distance self._m_has_field_show_hint_distance = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_show_hint_distance', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class SetGlobalDir(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_set_target: self.set_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_target(self): if hasattr(self, '_m_has_field_set_target'): return self._m_has_field_set_target self._m_has_field_set_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class LightLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LevelTagMapAreaConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfRatingLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tier: self.tier = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_requirement_array: self.requirement_array = Output.ArrayOfConfigGraphicsRequirementLengthU(self._io, self, self._root) if self.has_field_special_case_requirment: self.special_case_requirment = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_tier(self): if hasattr(self, '_m_has_field_tier'): return self._m_has_field_tier self._m_has_field_tier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tier', None) @property def has_field_requirement_array(self): if hasattr(self, '_m_has_field_requirement_array'): return self._m_has_field_requirement_array self._m_has_field_requirement_array = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_requirement_array', None) @property def has_field_special_case_requirment(self): if hasattr(self, '_m_has_field_special_case_requirment'): return self._m_has_field_special_case_requirment self._m_has_field_special_case_requirment = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_special_case_requirment', None) class EnumAttachPointTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AttachPointTargetType, self.data.value) return getattr(self, '_m_value', None) class StrengthenPointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRoute(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_local_id: self.local_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRouteType(self._io, self, self._root) if self.has_field_is_forward: self.is_forward = self._io.read_u1() if self.has_field_points: self.points = Output.ArrayOfConfigWaypointLengthU(self._io, self, self._root) if self.has_field_rot_type: self.rot_type = Output.EnumRotType(self._io, self, self._root) if self.has_field_rot_angle_type: self.rot_angle_type = Output.EnumRotAngleType(self._io, self, self._root) if self.has_field_arrive_range: self.arrive_range = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_arrive_range(self): if hasattr(self, '_m_has_field_arrive_range'): return self._m_has_field_arrive_range self._m_has_field_arrive_range = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_arrive_range', None) @property def has_field_rot_type(self): if hasattr(self, '_m_has_field_rot_type'): return self._m_has_field_rot_type self._m_has_field_rot_type = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_rot_type', None) @property def has_field_points(self): if hasattr(self, '_m_has_field_points'): return self._m_has_field_points self._m_has_field_points = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_points', None) @property def has_field_rot_angle_type(self): if hasattr(self, '_m_has_field_rot_angle_type'): return self._m_has_field_rot_angle_type self._m_has_field_rot_angle_type = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_rot_angle_type', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_local_id(self): if hasattr(self, '_m_has_field_local_id'): return self._m_has_field_local_id self._m_has_field_local_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_local_id', None) @property def has_field_is_forward(self): if hasattr(self, '_m_has_field_is_forward'): return self._m_has_field_is_forward self._m_has_field_is_forward = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_forward', None) class EnumNavmeshModeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NavmeshModeType, self.data.value) return getattr(self, '_m_value', None) class MpPlayStatisticConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_play_id: self.mp_play_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_settle_type: self.settle_type = Output.EnumMpPlayerSettleType(self._io, self, self._root) if self.has_field_settle_param: self.settle_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_client_sync_type: self.client_sync_type = Output.EnumMpPlayerSettleSyncType(self._io, self, self._root) if self.has_field_client_sync_param: self.client_sync_param = AuxTypes.String(self._io, self, self._root) if self.has_field_mpchallengetitle: self.mpchallengetitle = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mpchallenge: self.mpchallenge = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mpchallengestyle: self.mpchallengestyle = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_image: self.image = AuxTypes.String(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_mpchallenge(self): if hasattr(self, '_m_has_field_mpchallenge'): return self._m_has_field_mpchallenge self._m_has_field_mpchallenge = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mpchallenge', None) @property def has_field_mp_play_id(self): if hasattr(self, '_m_has_field_mp_play_id'): return self._m_has_field_mp_play_id self._m_has_field_mp_play_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mp_play_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_client_sync_type(self): if hasattr(self, '_m_has_field_client_sync_type'): return self._m_has_field_client_sync_type self._m_has_field_client_sync_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_client_sync_type', None) @property def has_field_mpchallengestyle(self): if hasattr(self, '_m_has_field_mpchallengestyle'): return self._m_has_field_mpchallengestyle self._m_has_field_mpchallengestyle = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_mpchallengestyle', None) @property def has_field_client_sync_param(self): if hasattr(self, '_m_has_field_client_sync_param'): return self._m_has_field_client_sync_param self._m_has_field_client_sync_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_client_sync_param', None) @property def has_field_mpchallengetitle(self): if hasattr(self, '_m_has_field_mpchallengetitle'): return self._m_has_field_mpchallengetitle self._m_has_field_mpchallengetitle = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_mpchallengetitle', None) @property def has_field_image(self): if hasattr(self, '_m_has_field_image'): return self._m_has_field_image self._m_has_field_image = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_image', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_settle_type(self): if hasattr(self, '_m_has_field_settle_type'): return self._m_has_field_settle_type self._m_has_field_settle_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_settle_type', None) @property def has_field_settle_param(self): if hasattr(self, '_m_has_field_settle_param'): return self._m_has_field_settle_param self._m_has_field_settle_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_settle_param', None) class DictOfEnumSceneSurfaceTypeDictOfEnumEFootprintPlatformConfigFootprintEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumSceneSurfaceTypeDictOfEnumEFootprintPlatformConfigFootprintEffect(self._io, self, self._root)) class DoActionByRayTagMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ugc_ray_trigger_directions: self.ugc_ray_trigger_directions = Output.ArrayOfEnumUgcRayTriggerDirectionTypeLengthU(self._io, self, self._root) if self.has_field_ray_tags: self.ray_tags = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_modifier_to_tags: self.modifier_to_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_raycast_interval: self.raycast_interval = self._io.read_f4le() @property def has_field_ugc_ray_trigger_directions(self): if hasattr(self, '_m_has_field_ugc_ray_trigger_directions'): return self._m_has_field_ugc_ray_trigger_directions self._m_has_field_ugc_ray_trigger_directions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ugc_ray_trigger_directions', None) @property def has_field_ray_tags(self): if hasattr(self, '_m_has_field_ray_tags'): return self._m_has_field_ray_tags self._m_has_field_ray_tags = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ray_tags', None) @property def has_field_raycast_interval(self): if hasattr(self, '_m_has_field_raycast_interval'): return self._m_has_field_raycast_interval self._m_has_field_raycast_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_raycast_interval', None) @property def has_field_modifier_to_tags(self): if hasattr(self, '_m_has_field_modifier_to_tags'): return self._m_has_field_modifier_to_tags self._m_has_field_modifier_to_tags = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_modifier_to_tags', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesStringConfigPerfNumberArrayItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberArrayItemOptionArrayInfo(self._io, self, self._root)) class ConfigPlayUiEffectAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_camera_effect_path: self.ui_camera_effect_path = AuxTypes.String(self._io, self, self._root) if self.has_field_main_camera_effect_path: self.main_camera_effect_path = AuxTypes.String(self._io, self, self._root) if self.has_field_is_remove: self.is_remove = self._io.read_u1() @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_ui_camera_effect_path(self): if hasattr(self, '_m_has_field_ui_camera_effect_path'): return self._m_has_field_ui_camera_effect_path self._m_has_field_ui_camera_effect_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_camera_effect_path', None) @property def has_field_main_camera_effect_path(self): if hasattr(self, '_m_has_field_main_camera_effect_path'): return self._m_has_field_main_camera_effect_path self._m_has_field_main_camera_effect_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_main_camera_effect_path', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_is_remove(self): if hasattr(self, '_m_has_field_is_remove'): return self._m_has_field_is_remove self._m_has_field_is_remove = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_remove', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class BlendMoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopMaterialOrderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_shop_type', None) class BySceneSurfaceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_filters: self.filters = Output.ArrayOfEnumSceneSurfaceTypeLengthU(self._io, self, self._root) if self.has_field_include: self.include = self._io.read_u1() if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) @property def has_field_filters(self): if hasattr(self, '_m_has_field_filters'): return self._m_has_field_filters self._m_has_field_filters = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_filters', None) @property def has_field_include(self): if hasattr(self, '_m_has_field_include'): return self._m_has_field_include self._m_has_field_include = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_include', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_offset', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigSceneMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_block_info: self.block_info = Output.ArrayOfConfigLevelBlockMetaLengthU(self._io, self, self._root) @property def has_field_block_info(self): if hasattr(self, '_m_has_field_block_info'): return self._m_has_field_block_info self._m_has_field_block_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_block_info', None) class SectrBakeLayerInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invisible_list: self.invisible_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_invisible_list(self): if hasattr(self, '_m_has_field_invisible_list'): return self._m_has_field_invisible_list self._m_has_field_invisible_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_invisible_list', None) class NewActivityPreviewConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NavTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEntityPropPerMpConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EntityPropPerMpConfig(self._io, self, self._root)) class ConfigTdPlay(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attack_speed_c: self.attack_speed_c = self._io.read_f4le() if self.has_field_tower_datas: self.tower_datas = Output.DictOfEnumTdPlayTowerTypeConfigTdPlayTowerData(self._io, self, self._root) @property def has_field_attack_speed_c(self): if hasattr(self, '_m_has_field_attack_speed_c'): return self._m_has_field_attack_speed_c self._m_has_field_attack_speed_c = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_speed_c', None) @property def has_field_tower_datas(self): if hasattr(self, '_m_has_field_tower_datas'): return self._m_has_field_tower_datas self._m_has_field_tower_datas = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tower_datas', None) class DictOfEnumMarkOrderAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumMarkOrderAuxTypesVlqBase128LeS(self._io, self, self._root)) class EnumMatchSubType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MatchSubType, self.data.value) return getattr(self, '_m_value', None) class QuestExcelConfigProxy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfCombineItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfCombineItemOptionArrayInfo(self._io, self, self._root) class ConfigModeStateMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_states: self.states = Output.DictOfAuxTypesStringConfigActionPanelState(self._io, self, self._root) if self.has_field_modes: self.modes = Output.DictOfEnumPlayModeTypeConfigActionPanelMode(self._io, self, self._root) @property def has_field_states(self): if hasattr(self, '_m_has_field_states'): return self._m_has_field_states self._m_has_field_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_states', None) @property def has_field_modes(self): if hasattr(self, '_m_has_field_modes'): return self._m_has_field_modes self._m_has_field_modes = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modes', None) class IrodoriMasterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeatherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PersonalLineActivityFeatureComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigQteStepPowerBarCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseCond(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_order_type: self.order_type = Output.EnumOrderingType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_order_type(self): if hasattr(self, '_m_has_field_order_type'): return self._m_has_field_order_type self._m_has_field_order_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_order_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def cond_type(self): if hasattr(self, '_m_cond_type'): return self._m_cond_type self._m_cond_type = self.base.cond_type return getattr(self, '_m_cond_type', None) class EnumUseSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UseSkillType, self.data.value) return getattr(self, '_m_value', None) class AudioSettingSliderPostEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.AudioSettingSlider(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_change_event: self.change_event = Output.ConfigWwiseString(self._io, self, self._root) @property def rtpc(self): if hasattr(self, '_m_rtpc'): return self._m_rtpc self._m_rtpc = self.base.rtpc return getattr(self, '_m_rtpc', None) @property def min_value(self): if hasattr(self, '_m_min_value'): return self._m_min_value self._m_min_value = self.base.min_value return getattr(self, '_m_min_value', None) @property def each_values(self): if hasattr(self, '_m_each_values'): return self._m_each_values self._m_each_values = self.base.each_values return getattr(self, '_m_each_values', None) @property def max_value(self): if hasattr(self, '_m_max_value'): return self._m_max_value self._m_max_value = self.base.max_value return getattr(self, '_m_max_value', None) @property def has_field_change_event(self): if hasattr(self, '_m_has_field_change_event'): return self._m_has_field_change_event self._m_has_field_change_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_change_event', None) @property def text_map(self): if hasattr(self, '_m_text_map'): return self._m_text_map self._m_text_map = self.base.text_map return getattr(self, '_m_text_map', None) class ReliquaryLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_exp', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_add_props', None) class ConfigGadgetSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSpecialCamera(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enter_angle: self.enter_angle = self._io.read_f4le() if self.has_field_exit_angle: self.exit_angle = self._io.read_f4le() @property def auto_turn_end_min(self): if hasattr(self, '_m_auto_turn_end_min'): return self._m_auto_turn_end_min self._m_auto_turn_end_min = self.base.auto_turn_end_min return getattr(self, '_m_auto_turn_end_min', None) @property def has_field_enter_angle(self): if hasattr(self, '_m_has_field_enter_angle'): return self._m_has_field_enter_angle self._m_has_field_enter_angle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enter_angle', None) @property def fov(self): if hasattr(self, '_m_fov'): return self._m_fov self._m_fov = self.base.fov return getattr(self, '_m_fov', None) @property def spherical_y_down(self): if hasattr(self, '_m_spherical_y_down'): return self._m_spherical_y_down self._m_spherical_y_down = self.base.spherical_y_down return getattr(self, '_m_spherical_y_down', None) @property def auto_turn_start_max(self): if hasattr(self, '_m_auto_turn_start_max'): return self._m_auto_turn_start_max self._m_auto_turn_start_max = self.base.auto_turn_start_max return getattr(self, '_m_auto_turn_start_max', None) @property def lock_spherical_y(self): if hasattr(self, '_m_lock_spherical_y'): return self._m_lock_spherical_y self._m_lock_spherical_y = self.base.lock_spherical_y return getattr(self, '_m_lock_spherical_y', None) @property def auto_turn_end_max(self): if hasattr(self, '_m_auto_turn_end_max'): return self._m_auto_turn_end_max self._m_auto_turn_end_max = self.base.auto_turn_end_max return getattr(self, '_m_auto_turn_end_max', None) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def height_adjust(self): if hasattr(self, '_m_height_adjust'): return self._m_height_adjust self._m_height_adjust = self.base.height_adjust return getattr(self, '_m_height_adjust', None) @property def has_field_exit_angle(self): if hasattr(self, '_m_has_field_exit_angle'): return self._m_has_field_exit_angle self._m_has_field_exit_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_exit_angle', None) @property def zoom(self): if hasattr(self, '_m_zoom'): return self._m_zoom self._m_zoom = self.base.zoom return getattr(self, '_m_zoom', None) @property def shape_center_offset(self): if hasattr(self, '_m_shape_center_offset'): return self._m_shape_center_offset self._m_shape_center_offset = self.base.shape_center_offset return getattr(self, '_m_shape_center_offset', None) @property def enter_shape(self): if hasattr(self, '_m_enter_shape'): return self._m_enter_shape self._m_enter_shape = self.base.enter_shape return getattr(self, '_m_enter_shape', None) @property def exit_shape(self): if hasattr(self, '_m_exit_shape'): return self._m_exit_shape self._m_exit_shape = self.base.exit_shape return getattr(self, '_m_exit_shape', None) @property def auto_turn_start_min(self): if hasattr(self, '_m_auto_turn_start_min'): return self._m_auto_turn_start_min self._m_auto_turn_start_min = self.base.auto_turn_start_min return getattr(self, '_m_auto_turn_start_min', None) @property def exit_radius(self): if hasattr(self, '_m_exit_radius'): return self._m_exit_radius self._m_exit_radius = self.base.exit_radius return getattr(self, '_m_exit_radius', None) @property def spherical_y_up(self): if hasattr(self, '_m_spherical_y_up'): return self._m_spherical_y_up self._m_spherical_y_up = self.base.spherical_y_up return getattr(self, '_m_spherical_y_up', None) @property def enter_radius(self): if hasattr(self, '_m_enter_radius'): return self._m_enter_radius self._m_enter_radius = self.base.enter_radius return getattr(self, '_m_enter_radius', None) @property def spherical_y(self): if hasattr(self, '_m_spherical_y'): return self._m_spherical_y self._m_spherical_y = self.base.spherical_y return getattr(self, '_m_spherical_y', None) class EnumOfferingMaxLevelLimitType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OfferingMaxLevelLimitType, self.data.value) return getattr(self, '_m_value', None) class ForgeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiFishingPretendBitesData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_min_pretend_distance: self.min_pretend_distance = self._io.read_f4le() if self.has_field_max_pretend_distance: self.max_pretend_distance = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_min_pretend_distance(self): if hasattr(self, '_m_has_field_min_pretend_distance'): return self._m_has_field_min_pretend_distance self._m_has_field_min_pretend_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_pretend_distance', None) @property def has_field_max_pretend_distance(self): if hasattr(self, '_m_has_field_max_pretend_distance'): return self._m_has_field_max_pretend_distance self._m_has_field_max_pretend_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_pretend_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ArrayOfConfigElementDecrateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigElementDecrate(self._io, self, self._root)) class TriggerThrowEquipPart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_equip_part: self.equip_part = AuxTypes.String(self._io, self, self._root) if self.has_field_chase_attack_target: self.chase_attack_target = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def has_field_chase_attack_target(self): if hasattr(self, '_m_has_field_chase_attack_target'): return self._m_has_field_chase_attack_target self._m_has_field_chase_attack_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_chase_attack_target', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_equip_part(self): if hasattr(self, '_m_has_field_equip_part'): return self._m_has_field_equip_part self._m_has_field_equip_part = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip_part', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_born', None) class RoutineCondContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRoutineCondType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class AvatarStageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigInterGrpId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grp_id: self.grp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_grp_id: self.next_grp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_index', None) @property def has_field_grp_id(self): if hasattr(self, '_m_has_field_grp_id'): return self._m_has_field_grp_id self._m_has_field_grp_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_grp_id', None) @property def has_field_next_grp_id(self): if hasattr(self, '_m_has_field_next_grp_id'): return self._m_has_field_next_grp_id self._m_has_field_next_grp_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_grp_id', None) class EnumEShaderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EShaderData, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigQteStepBaseComponentLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigQteStepBaseComponent(self._io, self, self._root)) class ArrayOfEnumMarkIconTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumMarkIconType(self._io, self, self._root)) class SetExtraAbilityEnable(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumRouteRecordMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RouteRecordMode, self.data.value) return getattr(self, '_m_value', None) class EnumDungeonStateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonStateType, self.data.value) return getattr(self, '_m_value', None) class ConfigSummon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_summon_tags: self.summon_tags = Output.ArrayOfConfigSummonTagLengthU(self._io, self, self._root) @property def has_field_summon_tags(self): if hasattr(self, '_m_has_field_summon_tags'): return self._m_has_field_summon_tags self._m_has_field_summon_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_summon_tags', None) class ConfigAiFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_trigger_distance: self.trigger_distance = self._io.read_f4le() if self.has_field_flee_angle: self.flee_angle = self._io.read_f4le() if self.has_field_flee_number_min: self.flee_number_min = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_flee_number_max: self.flee_number_max = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_flee_distance_min: self.flee_distance_min = self._io.read_f4le() if self.has_field_flee_distance_max: self.flee_distance_max = self._io.read_f4le() if self.has_field_turn_to_target: self.turn_to_target = self._io.read_u1() if self.has_field_restricted_by_defend_area: self.restricted_by_defend_area = self._io.read_u1() if self.has_field_expand_flee_angle_when_blocked: self.expand_flee_angle_when_blocked = self._io.read_u1() if self.has_field_kill_self_time: self.kill_self_time = self._io.read_f4le() @property def has_field_restricted_by_defend_area(self): if hasattr(self, '_m_has_field_restricted_by_defend_area'): return self._m_has_field_restricted_by_defend_area self._m_has_field_restricted_by_defend_area = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_restricted_by_defend_area', None) @property def has_field_flee_number_min(self): if hasattr(self, '_m_has_field_flee_number_min'): return self._m_has_field_flee_number_min self._m_has_field_flee_number_min = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_flee_number_min', None) @property def has_field_flee_angle(self): if hasattr(self, '_m_has_field_flee_angle'): return self._m_has_field_flee_angle self._m_has_field_flee_angle = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_flee_angle', None) @property def has_field_turn_to_target(self): if hasattr(self, '_m_has_field_turn_to_target'): return self._m_has_field_turn_to_target self._m_has_field_turn_to_target = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_turn_to_target', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_trigger_distance(self): if hasattr(self, '_m_has_field_trigger_distance'): return self._m_has_field_trigger_distance self._m_has_field_trigger_distance = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_trigger_distance', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_flee_distance_max(self): if hasattr(self, '_m_has_field_flee_distance_max'): return self._m_has_field_flee_distance_max self._m_has_field_flee_distance_max = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_flee_distance_max', None) @property def has_field_flee_number_max(self): if hasattr(self, '_m_has_field_flee_number_max'): return self._m_has_field_flee_number_max self._m_has_field_flee_number_max = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_flee_number_max', None) @property def has_field_kill_self_time(self): if hasattr(self, '_m_has_field_kill_self_time'): return self._m_has_field_kill_self_time self._m_has_field_kill_self_time = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_kill_self_time', None) @property def has_field_expand_flee_angle_when_blocked(self): if hasattr(self, '_m_has_field_expand_flee_angle_when_blocked'): return self._m_has_field_expand_flee_angle_when_blocked self._m_has_field_expand_flee_angle_when_blocked = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_expand_flee_angle_when_blocked', None) @property def has_field_flee_distance_min(self): if hasattr(self, '_m_has_field_flee_distance_min'): return self._m_has_field_flee_distance_min self._m_has_field_flee_distance_min = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_flee_distance_min', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ConfigHomeworldDefaultSave(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_arrangement_info_list: self.block_arrangement_info_list = Output.ArrayOfConfigHomeworldBlockDefaultSaveLengthU(self._io, self, self._root) if self.has_field_is_set_born_pos: self.is_set_born_pos = self._io.read_u1() if self.has_field_born_pos: self.born_pos = Output.Vector(self._io, self, self._root) if self.has_field_born_rot: self.born_rot = Output.Vector(self._io, self, self._root) if self.has_field_door_list: self.door_list = Output.ArrayOfConfigHomeworldFurnitureDefaultSaveLengthU(self._io, self, self._root) if self.has_field_stair_list: self.stair_list = Output.ArrayOfConfigHomeworldFurnitureDefaultSaveLengthU(self._io, self, self._root) if self.has_field_main_house: self.main_house = Output.ConfigHomeworldFurnitureDefaultSave(self._io, self, self._root) if self.has_field_comfort_value: self.comfort_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_djinn_pos: self.djinn_pos = Output.Vector(self._io, self, self._root) if self.has_field_tmp_version: self.tmp_version = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_block_arrangement_info_list(self): if hasattr(self, '_m_has_field_block_arrangement_info_list'): return self._m_has_field_block_arrangement_info_list self._m_has_field_block_arrangement_info_list = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_block_arrangement_info_list', None) @property def has_field_comfort_value(self): if hasattr(self, '_m_has_field_comfort_value'): return self._m_has_field_comfort_value self._m_has_field_comfort_value = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_comfort_value', None) @property def has_field_door_list(self): if hasattr(self, '_m_has_field_door_list'): return self._m_has_field_door_list self._m_has_field_door_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_door_list', None) @property def has_field_djinn_pos(self): if hasattr(self, '_m_has_field_djinn_pos'): return self._m_has_field_djinn_pos self._m_has_field_djinn_pos = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_djinn_pos', None) @property def has_field_stair_list(self): if hasattr(self, '_m_has_field_stair_list'): return self._m_has_field_stair_list self._m_has_field_stair_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_stair_list', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_born_rot(self): if hasattr(self, '_m_has_field_born_rot'): return self._m_has_field_born_rot self._m_has_field_born_rot = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_born_rot', None) @property def has_field_main_house(self): if hasattr(self, '_m_has_field_main_house'): return self._m_has_field_main_house self._m_has_field_main_house = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_main_house', None) @property def has_field_is_set_born_pos(self): if hasattr(self, '_m_has_field_is_set_born_pos'): return self._m_has_field_is_set_born_pos self._m_has_field_is_set_born_pos = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_is_set_born_pos', None) @property def has_field_born_pos(self): if hasattr(self, '_m_has_field_born_pos'): return self._m_has_field_born_pos self._m_has_field_born_pos = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_born_pos', None) @property def has_field_tmp_version(self): if hasattr(self, '_m_has_field_tmp_version'): return self._m_has_field_tmp_version self._m_has_field_tmp_version = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_tmp_version', None) class ArrayOfFetterConditionConfigLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FetterConditionConfig(self._io, self, self._root)) class WatcherSystemMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mixin_type: self.mixin_type = Output.EnumWatcherSystemMixinType(self._io, self, self._root) if self.has_field_listen_entity_type: self.listen_entity_type = Output.EnumWatcherSystemListenType(self._io, self, self._root) if self.has_field_listen_state_id: self.listen_state_id = AuxTypes.String(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_listen_entity_type(self): if hasattr(self, '_m_has_field_listen_entity_type'): return self._m_has_field_listen_entity_type self._m_has_field_listen_entity_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_listen_entity_type', None) @property def has_field_mixin_type(self): if hasattr(self, '_m_has_field_mixin_type'): return self._m_has_field_mixin_type self._m_has_field_mixin_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mixin_type', None) @property def has_field_listen_state_id(self): if hasattr(self, '_m_has_field_listen_state_id'): return self._m_has_field_listen_state_id self._m_has_field_listen_state_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_listen_state_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigWidgetMiracleRing(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_combat_destroy_distance: self.combat_destroy_distance = self._io.read_f4le() @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def has_field_combat_destroy_distance(self): if hasattr(self, '_m_has_field_combat_destroy_distance'): return self._m_has_field_combat_destroy_distance self._m_has_field_combat_destroy_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_combat_destroy_distance', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class GuideCmdTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GatherBundleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bundle_name: self.bundle_name = AuxTypes.String(self._io, self, self._root) if self.has_field_base_gadget_id: self.base_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_points: self.points = Output.ArrayOfPointInfoLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_bundle_name(self): if hasattr(self, '_m_has_field_bundle_name'): return self._m_has_field_bundle_name self._m_has_field_bundle_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_bundle_name', None) @property def has_field_base_gadget_id(self): if hasattr(self, '_m_has_field_base_gadget_id'): return self._m_has_field_base_gadget_id self._m_has_field_base_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_base_gadget_id', None) @property def has_field_points(self): if hasattr(self, '_m_has_field_points'): return self._m_has_field_points self._m_has_field_points = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_points', None) class PerceptionTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReputationEntranceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_text_id: self.text_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entrance_id: self.entrance_id = Output.EnumReputationEntranceType(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_vec: self.cond_vec = Output.ArrayOfReputationEntranceCondLengthS(self._io, self, self._root) if self.has_field_cond_name_vec: self.cond_name_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explain_title: self.explain_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_cond_name_vec(self): if hasattr(self, '_m_has_field_cond_name_vec'): return self._m_has_field_cond_name_vec self._m_has_field_cond_name_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cond_name_vec', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_entrance_id(self): if hasattr(self, '_m_has_field_entrance_id'): return self._m_has_field_entrance_id self._m_has_field_entrance_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_entrance_id', None) @property def has_field_cond_vec(self): if hasattr(self, '_m_has_field_cond_vec'): return self._m_has_field_cond_vec self._m_has_field_cond_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cond_vec', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_explain_title(self): if hasattr(self, '_m_has_field_explain_title'): return self._m_has_field_explain_title self._m_has_field_explain_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_explain_title', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_text_id(self): if hasattr(self, '_m_has_field_text_id'): return self._m_has_field_text_id self._m_has_field_text_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_text_id', None) class EnumContextEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ContextEventType, self.data.value) return getattr(self, '_m_value', None) class LampContributionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBoolForPlatforms(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ps4: self.ps4 = self._io.read_u1() if self.has_field_android: self.android = self._io.read_u1() if self.has_field_ios: self.ios = self._io.read_u1() if self.has_field_pc: self.pc = self._io.read_u1() if self.has_field_editor: self.editor = self._io.read_u1() @property def has_field_pc(self): if hasattr(self, '_m_has_field_pc'): return self._m_has_field_pc self._m_has_field_pc = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_pc', None) @property def has_field_editor(self): if hasattr(self, '_m_has_field_editor'): return self._m_has_field_editor self._m_has_field_editor = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_editor', None) @property def has_field_android(self): if hasattr(self, '_m_has_field_android'): return self._m_has_field_android self._m_has_field_android = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_android', None) @property def has_field_ios(self): if hasattr(self, '_m_has_field_ios'): return self._m_has_field_ios self._m_has_field_ios = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ios', None) @property def has_field_ps4(self): if hasattr(self, '_m_has_field_ps4'): return self._m_has_field_ps4 self._m_has_field_ps4 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ps4', None) class ConfigMusicUInt32equalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CaptureCodexShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLocalTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLocalEntity(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_flag: self.trigger_flag = Output.EnumTriggerFlag(self._io, self, self._root) if self.has_field_shape: self.shape = Output.DispConfigBaseShape(self._io, self, self._root) if self.has_field_check_count: self.check_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trigger_interval: self.trigger_interval = self._io.read_f4le() if self.has_field_vector_param: self.vector_param = Output.Vector(self._io, self, self._root) if self.has_field_float_param: self.float_param = self._io.read_f4le() if self.has_field_string_param: self.string_param = AuxTypes.String(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def has_field_shape(self): if hasattr(self, '_m_has_field_shape'): return self._m_has_field_shape self._m_has_field_shape = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shape', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_vector_param(self): if hasattr(self, '_m_has_field_vector_param'): return self._m_has_field_vector_param self._m_has_field_vector_param = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_vector_param', None) @property def has_field_trigger_flag(self): if hasattr(self, '_m_has_field_trigger_flag'): return self._m_has_field_trigger_flag self._m_has_field_trigger_flag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_flag', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_float_param(self): if hasattr(self, '_m_has_field_float_param'): return self._m_has_field_float_param self._m_has_field_float_param = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_float_param', None) @property def has_field_string_param(self): if hasattr(self, '_m_has_field_string_param'): return self._m_has_field_string_param self._m_has_field_string_param = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_string_param', None) @property def has_field_check_count(self): if hasattr(self, '_m_has_field_check_count'): return self._m_has_field_check_count self._m_has_field_check_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_check_count', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def check_dist(self): if hasattr(self, '_m_check_dist'): return self._m_check_dist self._m_check_dist = self.base.check_dist return getattr(self, '_m_check_dist', None) @property def with_go(self): if hasattr(self, '_m_with_go'): return self._m_with_go self._m_with_go = self.base.with_go return getattr(self, '_m_with_go', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_trigger_interval(self): if hasattr(self, '_m_has_field_trigger_interval'): return self._m_has_field_trigger_interval self._m_has_field_trigger_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_trigger_interval', None) class PushTipsTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RocketJumpExt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_xz_multiplier: self.xz_multiplier = self._io.read_f4le() if self.has_field_y_multiplier: self.y_multiplier = self._io.read_f4le() @property def has_field_xz_multiplier(self): if hasattr(self, '_m_has_field_xz_multiplier'): return self._m_has_field_xz_multiplier self._m_has_field_xz_multiplier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_xz_multiplier', None) @property def has_field_y_multiplier(self): if hasattr(self, '_m_has_field_y_multiplier'): return self._m_has_field_y_multiplier self._m_has_field_y_multiplier = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y_multiplier', None) class GuideLevelTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySpiceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnvZoneEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetAbilityGroupGenerator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class EnumEShaderPlus(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EShaderPlus, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiWanderData(self._io, self, self._root) class SeaLampSectionMainQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_intro: self.intro = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_intro(self): if hasattr(self, '_m_has_field_intro'): return self._m_has_field_intro self._m_has_field_intro = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_intro', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_day', None) class ConfigGadgetDoAttackEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseGadgetTriggerAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_event: self.attack_event = AuxTypes.String(self._io, self, self._root) @property def has_field_attack_event(self): if hasattr(self, '_m_has_field_attack_event'): return self._m_has_field_attack_event self._m_has_field_attack_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_event', None) class HomeWorldFurnitureTypeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCostumeAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_wear_voice: self.wear_voice = Output.VoiceTriggerIdentity(self._io, self, self._root) @property def has_field_wear_voice(self): if hasattr(self, '_m_has_field_wear_voice'): return self._m_has_field_wear_voice self._m_has_field_wear_voice = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_wear_voice', None) class ArrayOfConfigPerfRatingLevelLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigPerfRatingLevel(self._io, self, self._root)) class ArrayOfRegionSearchCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RegionSearchCond(self._io, self, self._root)) class DebugMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ColorVector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_r: self.r = self._io.read_f4le() if self.has_field_g: self.g = self._io.read_f4le() if self.has_field_b: self.b = self._io.read_f4le() if self.has_field_a: self.a = self._io.read_f4le() @property def has_field_r(self): if hasattr(self, '_m_has_field_r'): return self._m_has_field_r self._m_has_field_r = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_r', None) @property def has_field_g(self): if hasattr(self, '_m_has_field_g'): return self._m_has_field_g self._m_has_field_g = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_g', None) @property def has_field_b(self): if hasattr(self, '_m_has_field_b'): return self._m_has_field_b self._m_has_field_b = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_b', None) @property def has_field_a(self): if hasattr(self, '_m_has_field_a'): return self._m_has_field_a self._m_has_field_a = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_a', None) class QteTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RetreatTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BartenderMaterial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_count', None) class TowerLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_group_id: self.level_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_index: self.level_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_conds: self.conds = Output.ArrayOfTowerConditionLengthS(self._io, self, self._root) if self.has_field_tower_buff_config_str_list: self.tower_buff_config_str_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_daily_reward_id: self.daily_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_first_pass_reward_id: self.first_pass_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_first_monster_list: self.first_monster_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_second_monster_list: self.second_monster_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_first_monster_list(self): if hasattr(self, '_m_has_field_first_monster_list'): return self._m_has_field_first_monster_list self._m_has_field_first_monster_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_first_monster_list', None) @property def has_field_first_pass_reward_id(self): if hasattr(self, '_m_has_field_first_pass_reward_id'): return self._m_has_field_first_pass_reward_id self._m_has_field_first_pass_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_first_pass_reward_id', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_level_group_id(self): if hasattr(self, '_m_has_field_level_group_id'): return self._m_has_field_level_group_id self._m_has_field_level_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_group_id', None) @property def has_field_level_index(self): if hasattr(self, '_m_has_field_level_index'): return self._m_has_field_level_index self._m_has_field_level_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_index', None) @property def has_field_conds(self): if hasattr(self, '_m_has_field_conds'): return self._m_has_field_conds self._m_has_field_conds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_conds', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_tower_buff_config_str_list(self): if hasattr(self, '_m_has_field_tower_buff_config_str_list'): return self._m_has_field_tower_buff_config_str_list self._m_has_field_tower_buff_config_str_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tower_buff_config_str_list', None) @property def has_field_daily_reward_id(self): if hasattr(self, '_m_has_field_daily_reward_id'): return self._m_has_field_daily_reward_id self._m_has_field_daily_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_daily_reward_id', None) @property def has_field_second_monster_list(self): if hasattr(self, '_m_has_field_second_monster_list'): return self._m_has_field_second_monster_list self._m_has_field_second_monster_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_second_monster_list', None) class WinterCampSnowmanExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBornByPredicatePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_time_for_predictive: self.time_for_predictive = self._io.read_f4le() @property def has_field_time_for_predictive(self): if hasattr(self, '_m_has_field_time_for_predictive'): return self._m_has_field_time_for_predictive self._m_has_field_time_for_predictive = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time_for_predictive', None) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigDirectionByLookAtEntityFix(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class BySummonTagValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_summon_tag: self.summon_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicInt(self._io, self, self._root) @property def has_field_summon_tag(self): if hasattr(self, '_m_has_field_summon_tag'): return self._m_has_field_summon_tag self._m_has_field_summon_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_summon_tag', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DispConfigCameraSplineBasePath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigCameraSplineBasePath(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCameraSplineCameraPath(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCameraSplineTargetPath(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ElementConvertToChargeBarValueMixinItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_ratio: self.ratio = self._io.read_f4le() @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ratio', None) class SelectTargetsByTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tag: self.tag = AuxTypes.String(self._io, self, self._root) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tag', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class ConfigDynamicAbilityPreload(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_preload_effect: self.preload_effect = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_preload_gadget: self.preload_gadget = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_preload_camera: self.preload_camera = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_preload_skill_icon: self.preload_skill_icon = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_preload_effect(self): if hasattr(self, '_m_has_field_preload_effect'): return self._m_has_field_preload_effect self._m_has_field_preload_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_preload_effect', None) @property def has_field_preload_gadget(self): if hasattr(self, '_m_has_field_preload_gadget'): return self._m_has_field_preload_gadget self._m_has_field_preload_gadget = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_preload_gadget', None) @property def has_field_preload_camera(self): if hasattr(self, '_m_has_field_preload_camera'): return self._m_has_field_preload_camera self._m_has_field_preload_camera = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_preload_camera', None) @property def has_field_preload_skill_icon(self): if hasattr(self, '_m_has_field_preload_skill_icon'): return self._m_has_field_preload_skill_icon self._m_has_field_preload_skill_icon = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_preload_skill_icon', None) class DictOfAuxTypesVlqBase128LeSConfigAiSpacialWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialWanderData(self._io, self, self._root)) class EnumAbilityGroupTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityGroupTargetType, self.data.value) return getattr(self, '_m_value', None) class ConfigCameraSplineInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_path: self.camera_path = Output.ConfigCameraSplineCameraPath(self._io, self, self._root) if self.has_field_target_path: self.target_path = Output.ConfigCameraSplineTargetPath(self._io, self, self._root) if self.has_field_target_duration: self.target_duration = self._io.read_f4le() @property def has_field_camera_path(self): if hasattr(self, '_m_has_field_camera_path'): return self._m_has_field_camera_path self._m_has_field_camera_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_path', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_target_path(self): if hasattr(self, '_m_has_field_target_path'): return self._m_has_field_target_path self._m_has_field_target_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_path', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_target_duration(self): if hasattr(self, '_m_has_field_target_duration'): return self._m_has_field_target_duration self._m_has_field_target_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigGuideEndTaskAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_task_name: self.task_name = AuxTypes.String(self._io, self, self._root) @property def has_field_task_name(self): if hasattr(self, '_m_has_field_task_name'): return self._m_has_field_task_name self._m_has_field_task_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_task_name', None) class FishExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDialogScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_dialogs: self.next_dialogs = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_talk_show_type: self.talk_show_type = Output.EnumTalkShowType(self._io, self, self._root) if self.has_field_talk_role: self.talk_role = Output.TalkRoleEx(self._io, self, self._root) if self.has_field_talk_content: self.talk_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_title: self.talk_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_role_name: self.talk_role_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_asset_path: self.talk_asset_path = AuxTypes.String(self._io, self, self._root) if self.has_field_talk_asset_path_alter: self.talk_asset_path_alter = AuxTypes.String(self._io, self, self._root) if self.has_field_talk_audio_name: self.talk_audio_name = AuxTypes.String(self._io, self, self._root) if self.has_field_action_before: self.action_before = AuxTypes.String(self._io, self, self._root) if self.has_field_action_while: self.action_while = AuxTypes.String(self._io, self, self._root) if self.has_field_action_after: self.action_after = AuxTypes.String(self._io, self, self._root) if self.has_field_show_duration: self.show_duration = self._io.read_f4le() if self.has_field_option_icon: self.option_icon = AuxTypes.String(self._io, self, self._root) @property def has_field_talk_content(self): if hasattr(self, '_m_has_field_talk_content'): return self._m_has_field_talk_content self._m_has_field_talk_content = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_talk_content', None) @property def has_field_action_after(self): if hasattr(self, '_m_has_field_action_after'): return self._m_has_field_action_after self._m_has_field_action_after = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_action_after', None) @property def has_field_talk_title(self): if hasattr(self, '_m_has_field_talk_title'): return self._m_has_field_talk_title self._m_has_field_talk_title = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_talk_title', None) @property def has_field_talk_role_name(self): if hasattr(self, '_m_has_field_talk_role_name'): return self._m_has_field_talk_role_name self._m_has_field_talk_role_name = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_talk_role_name', None) @property def has_field_next_dialogs(self): if hasattr(self, '_m_has_field_next_dialogs'): return self._m_has_field_next_dialogs self._m_has_field_next_dialogs = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_next_dialogs', None) @property def has_field_talk_show_type(self): if hasattr(self, '_m_has_field_talk_show_type'): return self._m_has_field_talk_show_type self._m_has_field_talk_show_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_talk_show_type', None) @property def has_field_option_icon(self): if hasattr(self, '_m_has_field_option_icon'): return self._m_has_field_option_icon self._m_has_field_option_icon = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_option_icon', None) @property def has_field_action_while(self): if hasattr(self, '_m_has_field_action_while'): return self._m_has_field_action_while self._m_has_field_action_while = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_action_while', None) @property def has_field_talk_asset_path_alter(self): if hasattr(self, '_m_has_field_talk_asset_path_alter'): return self._m_has_field_talk_asset_path_alter self._m_has_field_talk_asset_path_alter = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_talk_asset_path_alter', None) @property def has_field_show_duration(self): if hasattr(self, '_m_has_field_show_duration'): return self._m_has_field_show_duration self._m_has_field_show_duration = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_show_duration', None) @property def has_field_talk_asset_path(self): if hasattr(self, '_m_has_field_talk_asset_path'): return self._m_has_field_talk_asset_path self._m_has_field_talk_asset_path = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_talk_asset_path', None) @property def has_field_talk_audio_name(self): if hasattr(self, '_m_has_field_talk_audio_name'): return self._m_has_field_talk_audio_name self._m_has_field_talk_audio_name = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_talk_audio_name', None) @property def has_field_talk_role(self): if hasattr(self, '_m_has_field_talk_role'): return self._m_has_field_talk_role self._m_has_field_talk_role = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_talk_role', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_action_before(self): if hasattr(self, '_m_has_field_action_before'): return self._m_has_field_action_before self._m_has_field_action_before = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_action_before', None) class ArrayOfDungeonCondConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DungeonCondConfig(self._io, self, self._root)) class EnumTileCampType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TileCampType, self.data.value) return getattr(self, '_m_value', None) class ConfigWidgetToyClintCollector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_type: self.target_type = Output.EnumCollectorType(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_recharge_points: self.recharge_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_points: self.max_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_gadget_id: self.effect_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_use_gadget_id: self.use_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_allow_other_world: self.allow_other_world = self._io.read_u1() @property def has_field_max_points(self): if hasattr(self, '_m_has_field_max_points'): return self._m_has_field_max_points self._m_has_field_max_points = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_points', None) @property def has_field_allow_other_world(self): if hasattr(self, '_m_has_field_allow_other_world'): return self._m_has_field_allow_other_world self._m_has_field_allow_other_world = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_allow_other_world', None) @property def has_field_effect_gadget_id(self): if hasattr(self, '_m_has_field_effect_gadget_id'): return self._m_has_field_effect_gadget_id self._m_has_field_effect_gadget_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_effect_gadget_id', None) @property def has_field_use_gadget_id(self): if hasattr(self, '_m_has_field_use_gadget_id'): return self._m_has_field_use_gadget_id self._m_has_field_use_gadget_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_use_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_recharge_points(self): if hasattr(self, '_m_has_field_recharge_points'): return self._m_has_field_recharge_points self._m_has_field_recharge_points = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_recharge_points', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_type', None) class DispContextCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ContextCondition(self._io, self, self._root) elif _on == 4: self.data = Output.ContextConditionQuestState(self._io, self, self._root) elif _on == 6: self.data = Output.ContextConditionMainQuestVisible(self._io, self, self._root) elif _on == 7: self.data = Output.ContextConditionChapterQuestState(self._io, self, self._root) elif _on == 1: self.data = Output.ContextConditionAnd(self._io, self, self._root) elif _on == 3: self.data = Output.ContextConditionNot(self._io, self, self._root) elif _on == 5: self.data = Output.ContextConditionMainQuestState(self._io, self, self._root) elif _on == 8: self.data = Output.ContextConditionChapterQuestVisible(self._io, self, self._root) elif _on == 9: self.data = Output.ContextConditionQuestGlobalVar(self._io, self, self._root) elif _on == 2: self.data = Output.ContextConditionOr(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class RemoveAvatarSkillInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_after_remove: self.refresh_after_remove = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_refresh_after_remove(self): if hasattr(self, '_m_has_field_refresh_after_remove'): return self._m_has_field_refresh_after_remove self._m_has_field_refresh_after_remove = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_refresh_after_remove', None) class EnumBuffStackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BuffStackType, self.data.value) return getattr(self, '_m_value', None) class InvestigationMonsterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id_list: self.monster_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_id_list: self.group_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_unlock_parent_quest_id: self.unlock_parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_unlock_parent_quest_id: self.pre_unlock_parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_chapter_id_list: self.unlock_chapter_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_unlock_wq_parent_quest_id_list: self.unlock_wq_parent_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_wq_accept_hint: self.wq_accept_hint = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_active_unlock_quest_activity_id: self.active_unlock_quest_activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_mark_create_type: self.map_mark_create_type = Output.EnumInvestigationMonsterMapMarkCreateType(self._io, self, self._root) if self.has_field_map_mark_create_condition: self.map_mark_create_condition = Output.InvestigationMonsterMapMarkCreateCondition(self._io, self, self._root) if self.has_field_monster_category: self.monster_category = Output.EnumMonsterCategory(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lock_desc: self.lock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_occupied_quest_id_list: self.occupied_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_monster_category(self): if hasattr(self, '_m_has_field_monster_category'): return self._m_has_field_monster_category self._m_has_field_monster_category = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_monster_category', None) @property def has_field_wq_accept_hint(self): if hasattr(self, '_m_has_field_wq_accept_hint'): return self._m_has_field_wq_accept_hint self._m_has_field_wq_accept_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_wq_accept_hint', None) @property def has_field_active_unlock_quest_activity_id(self): if hasattr(self, '_m_has_field_active_unlock_quest_activity_id'): return self._m_has_field_active_unlock_quest_activity_id self._m_has_field_active_unlock_quest_activity_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_active_unlock_quest_activity_id', None) @property def has_field_map_mark_create_type(self): if hasattr(self, '_m_has_field_map_mark_create_type'): return self._m_has_field_map_mark_create_type self._m_has_field_map_mark_create_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_map_mark_create_type', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_pre_unlock_parent_quest_id(self): if hasattr(self, '_m_has_field_pre_unlock_parent_quest_id'): return self._m_has_field_pre_unlock_parent_quest_id self._m_has_field_pre_unlock_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_unlock_parent_quest_id', None) @property def has_field_group_id_list(self): if hasattr(self, '_m_has_field_group_id_list'): return self._m_has_field_group_id_list self._m_has_field_group_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id_list', None) @property def has_field_unlock_wq_parent_quest_id_list(self): if hasattr(self, '_m_has_field_unlock_wq_parent_quest_id_list'): return self._m_has_field_unlock_wq_parent_quest_id_list self._m_has_field_unlock_wq_parent_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_wq_parent_quest_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_unlock_parent_quest_id(self): if hasattr(self, '_m_has_field_unlock_parent_quest_id'): return self._m_has_field_unlock_parent_quest_id self._m_has_field_unlock_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_parent_quest_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_monster_id_list(self): if hasattr(self, '_m_has_field_monster_id_list'): return self._m_has_field_monster_id_list self._m_has_field_monster_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_monster_id_list', None) @property def has_field_occupied_quest_id_list(self): if hasattr(self, '_m_has_field_occupied_quest_id_list'): return self._m_has_field_occupied_quest_id_list self._m_has_field_occupied_quest_id_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_occupied_quest_id_list', None) @property def has_field_unlock_chapter_id_list(self): if hasattr(self, '_m_has_field_unlock_chapter_id_list'): return self._m_has_field_unlock_chapter_id_list self._m_has_field_unlock_chapter_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_chapter_id_list', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_map_mark_create_condition(self): if hasattr(self, '_m_has_field_map_mark_create_condition'): return self._m_has_field_map_mark_create_condition self._m_has_field_map_mark_create_condition = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_map_mark_create_condition', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_lock_desc(self): if hasattr(self, '_m_has_field_lock_desc'): return self._m_has_field_lock_desc self._m_has_field_lock_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_lock_desc', None) class ConfigAvatarAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCharacterAudio(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_move_state_audio: self.move_state_audio = Output.ConfigMoveStateAudio(self._io, self, self._root) if self.has_field_combat_speech: self.combat_speech = Output.ConfigCombatSpeech(self._io, self, self._root) if self.has_field_voice_switch: self.voice_switch = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_body_type_switch: self.body_type_switch = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_listener_liftup: self.listener_liftup = self._io.read_f4le() if self.has_field_surface_prober_liftup: self.surface_prober_liftup = self._io.read_f4le() @property def has_field_voice_switch(self): if hasattr(self, '_m_has_field_voice_switch'): return self._m_has_field_voice_switch self._m_has_field_voice_switch = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_voice_switch', None) @property def has_field_listener_liftup(self): if hasattr(self, '_m_has_field_listener_liftup'): return self._m_has_field_listener_liftup self._m_has_field_listener_liftup = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_listener_liftup', None) @property def destroy_event(self): if hasattr(self, '_m_destroy_event'): return self._m_destroy_event self._m_destroy_event = self.base.destroy_event return getattr(self, '_m_destroy_event', None) @property def anim_audio(self): if hasattr(self, '_m_anim_audio'): return self._m_anim_audio self._m_anim_audio = self.base.anim_audio return getattr(self, '_m_anim_audio', None) @property def has_field_move_state_audio(self): if hasattr(self, '_m_has_field_move_state_audio'): return self._m_has_field_move_state_audio self._m_has_field_move_state_audio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_move_state_audio', None) @property def has_field_surface_prober_liftup(self): if hasattr(self, '_m_has_field_surface_prober_liftup'): return self._m_has_field_surface_prober_liftup self._m_has_field_surface_prober_liftup = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_surface_prober_liftup', None) @property def disable_event(self): if hasattr(self, '_m_disable_event'): return self._m_disable_event self._m_disable_event = self.base.disable_event return getattr(self, '_m_disable_event', None) @property def has_field_combat_speech(self): if hasattr(self, '_m_has_field_combat_speech'): return self._m_has_field_combat_speech self._m_has_field_combat_speech = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_combat_speech', None) @property def enable_event(self): if hasattr(self, '_m_enable_event'): return self._m_enable_event self._m_enable_event = self.base.enable_event return getattr(self, '_m_enable_event', None) @property def has_field_body_type_switch(self): if hasattr(self, '_m_has_field_body_type_switch'): return self._m_has_field_body_type_switch self._m_has_field_body_type_switch = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_body_type_switch', None) @property def init_event(self): if hasattr(self, '_m_init_event'): return self._m_init_event self._m_init_event = self.base.init_event return getattr(self, '_m_init_event', None) class DispConfigBaseGadgetTriggerAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseGadgetTriggerAction(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetDoAttackEvent(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigGadgetDamageByAttackValue(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigGadgetTriggerAbility(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DispConfigBulletMoveAngle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBulletMoveAngle(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBulletMoveAngleByVelocity(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBulletMoveAngleRotating(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigClimateTemperatureOptions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed: self.speed = self._io.read_f4le() @property def has_field_speed(self): if hasattr(self, '_m_has_field_speed'): return self._m_has_field_speed self._m_has_field_speed = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed', None) class ConfigLcGadgetInteeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_dic: self.config_dic = Output.DictOfAuxTypesStringConfigLcGadgetIntee(self._io, self, self._root) @property def has_field_config_dic(self): if hasattr(self, '_m_has_field_config_dic'): return self._m_has_field_config_dic self._m_has_field_config_dic = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_dic', None) class DictOfEnumJsonClimateTypeArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumJsonClimateTypeArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root)) class CityTaskOpenExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_backup_vec: self.backup_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_backup_vec(self): if hasattr(self, '_m_has_field_backup_vec'): return self._m_has_field_backup_vec self._m_has_field_backup_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_backup_vec', None) class LevelTagGroupsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPotionDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_difficulty_level: self.difficulty_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_up_level: self.dungeon_up_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_difficulty_level(self): if hasattr(self, '_m_has_field_difficulty_level'): return self._m_has_field_difficulty_level self._m_has_field_difficulty_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_difficulty_level', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_dungeon_up_level(self): if hasattr(self, '_m_has_field_dungeon_up_level'): return self._m_has_field_dungeon_up_level self._m_has_field_dungeon_up_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_up_level', None) class EnumPropertyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PropertyType, self.data.value) return getattr(self, '_m_value', None) class HuntingRefreshExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumHuntingOfferDifficultyType(self._io, self, self._root) if self.has_field_region_id: self.region_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_reward_id: self.finish_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_region_id(self): if hasattr(self, '_m_has_field_region_id'): return self._m_has_field_region_id self._m_has_field_region_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_region_id', None) @property def has_field_finish_reward_id(self): if hasattr(self, '_m_has_field_finish_reward_id'): return self._m_has_field_finish_reward_id self._m_has_field_finish_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_finish_reward_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class AvatarFilterTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumBlendMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlendMoveType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetMisc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chest: self.chest = Output.ConfigChest(self._io, self, self._root) if self.has_field_gear: self.gear = Output.ConfigGear(self._io, self, self._root) if self.has_field_force_field: self.force_field = Output.DispConfigScenePoint(self._io, self, self._root) if self.has_field_crystal: self.crystal = Output.ConfigCrystal(self._io, self, self._root) if self.has_field_seal: self.seal = Output.ConfigSeal(self._io, self, self._root) if self.has_field_pickup: self.pickup = Output.ConfigPickup(self._io, self, self._root) if self.has_field_wind_seed: self.wind_seed = Output.ConfigWindSeed(self._io, self, self._root) if self.has_field_cannon: self.cannon = Output.ConfigCannon(self._io, self, self._root) if self.has_field_gadget_console: self.gadget_console = Output.ConfigGadgetConsole(self._io, self, self._root) if self.has_field_auto_door: self.auto_door = Output.ConfigAutoDool(self._io, self, self._root) if self.has_field_custom_gadget_node: self.custom_gadget_node = Output.ConfigCustomGadgetNode(self._io, self, self._root) if self.has_field_escape_effect: self.escape_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_guide_point: self.guide_point = self._io.read_u1() if self.has_field_is_ui_point: self.is_ui_point = self._io.read_u1() if self.has_field_guide_point_managed_by_indicator: self.guide_point_managed_by_indicator = self._io.read_u1() if self.has_field_guide_point_type: self.guide_point_type = Output.EnumTargetIndicatorType(self._io, self, self._root) if self.has_field_target_indicator_y_offset: self.target_indicator_y_offset = self._io.read_f4le() if self.has_field_guide_point_config: self.guide_point_config = Output.ConfigGuidePoint(self._io, self, self._root) @property def has_field_target_indicator_y_offset(self): if hasattr(self, '_m_has_field_target_indicator_y_offset'): return self._m_has_field_target_indicator_y_offset self._m_has_field_target_indicator_y_offset = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_target_indicator_y_offset', None) @property def has_field_gear(self): if hasattr(self, '_m_has_field_gear'): return self._m_has_field_gear self._m_has_field_gear = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_gear', None) @property def has_field_crystal(self): if hasattr(self, '_m_has_field_crystal'): return self._m_has_field_crystal self._m_has_field_crystal = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_crystal', None) @property def has_field_guide_point_config(self): if hasattr(self, '_m_has_field_guide_point_config'): return self._m_has_field_guide_point_config self._m_has_field_guide_point_config = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_guide_point_config', None) @property def has_field_wind_seed(self): if hasattr(self, '_m_has_field_wind_seed'): return self._m_has_field_wind_seed self._m_has_field_wind_seed = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_wind_seed', None) @property def has_field_escape_effect(self): if hasattr(self, '_m_has_field_escape_effect'): return self._m_has_field_escape_effect self._m_has_field_escape_effect = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_escape_effect', None) @property def has_field_pickup(self): if hasattr(self, '_m_has_field_pickup'): return self._m_has_field_pickup self._m_has_field_pickup = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_pickup', None) @property def has_field_custom_gadget_node(self): if hasattr(self, '_m_has_field_custom_gadget_node'): return self._m_has_field_custom_gadget_node self._m_has_field_custom_gadget_node = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_custom_gadget_node', None) @property def has_field_cannon(self): if hasattr(self, '_m_has_field_cannon'): return self._m_has_field_cannon self._m_has_field_cannon = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_cannon', None) @property def has_field_is_ui_point(self): if hasattr(self, '_m_has_field_is_ui_point'): return self._m_has_field_is_ui_point self._m_has_field_is_ui_point = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_is_ui_point', None) @property def has_field_force_field(self): if hasattr(self, '_m_has_field_force_field'): return self._m_has_field_force_field self._m_has_field_force_field = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_force_field', None) @property def has_field_gadget_console(self): if hasattr(self, '_m_has_field_gadget_console'): return self._m_has_field_gadget_console self._m_has_field_gadget_console = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_gadget_console', None) @property def has_field_chest(self): if hasattr(self, '_m_has_field_chest'): return self._m_has_field_chest self._m_has_field_chest = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_chest', None) @property def has_field_guide_point_type(self): if hasattr(self, '_m_has_field_guide_point_type'): return self._m_has_field_guide_point_type self._m_has_field_guide_point_type = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_guide_point_type', None) @property def has_field_seal(self): if hasattr(self, '_m_has_field_seal'): return self._m_has_field_seal self._m_has_field_seal = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_seal', None) @property def has_field_guide_point(self): if hasattr(self, '_m_has_field_guide_point'): return self._m_has_field_guide_point self._m_has_field_guide_point = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_guide_point', None) @property def has_field_auto_door(self): if hasattr(self, '_m_has_field_auto_door'): return self._m_has_field_auto_door self._m_has_field_auto_door = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_auto_door', None) @property def has_field_guide_point_managed_by_indicator(self): if hasattr(self, '_m_has_field_guide_point_managed_by_indicator'): return self._m_has_field_guide_point_managed_by_indicator self._m_has_field_guide_point_managed_by_indicator = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_guide_point_managed_by_indicator', None) class FireworksLauncherMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_count_down_modifier: self.start_count_down_modifier = AuxTypes.String(self._io, self, self._root) if self.has_field_on_evt_start_count_down: self.on_evt_start_count_down = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_all_bullets_fired: self.on_all_bullets_fired = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_gv_fw_bullet_item_id: self.gv_fw_bullet_item_id = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_color_h: self.gv_fw_color_h = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_scale: self.gv_fw_scale = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_angle: self.gv_fw_angle = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_max_particle_count: self.gv_fw_max_particle_count = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_face_to_camera: self.gv_fw_face_to_camera = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_fw_bullet_life_time: self.gv_fw_bullet_life_time = AuxTypes.String(self._io, self, self._root) @property def has_field_gv_fw_angle(self): if hasattr(self, '_m_has_field_gv_fw_angle'): return self._m_has_field_gv_fw_angle self._m_has_field_gv_fw_angle = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_gv_fw_angle', None) @property def has_field_gv_fw_bullet_item_id(self): if hasattr(self, '_m_has_field_gv_fw_bullet_item_id'): return self._m_has_field_gv_fw_bullet_item_id self._m_has_field_gv_fw_bullet_item_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_gv_fw_bullet_item_id', None) @property def has_field_gv_fw_face_to_camera(self): if hasattr(self, '_m_has_field_gv_fw_face_to_camera'): return self._m_has_field_gv_fw_face_to_camera self._m_has_field_gv_fw_face_to_camera = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_gv_fw_face_to_camera', None) @property def has_field_start_count_down_modifier(self): if hasattr(self, '_m_has_field_start_count_down_modifier'): return self._m_has_field_start_count_down_modifier self._m_has_field_start_count_down_modifier = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_start_count_down_modifier', None) @property def has_field_gv_fw_max_particle_count(self): if hasattr(self, '_m_has_field_gv_fw_max_particle_count'): return self._m_has_field_gv_fw_max_particle_count self._m_has_field_gv_fw_max_particle_count = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_gv_fw_max_particle_count', None) @property def has_field_gv_fw_color_h(self): if hasattr(self, '_m_has_field_gv_fw_color_h'): return self._m_has_field_gv_fw_color_h self._m_has_field_gv_fw_color_h = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_gv_fw_color_h', None) @property def has_field_on_all_bullets_fired(self): if hasattr(self, '_m_has_field_on_all_bullets_fired'): return self._m_has_field_on_all_bullets_fired self._m_has_field_on_all_bullets_fired = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_on_all_bullets_fired', None) @property def has_field_on_evt_start_count_down(self): if hasattr(self, '_m_has_field_on_evt_start_count_down'): return self._m_has_field_on_evt_start_count_down self._m_has_field_on_evt_start_count_down = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_on_evt_start_count_down', None) @property def has_field_gv_fw_bullet_life_time(self): if hasattr(self, '_m_has_field_gv_fw_bullet_life_time'): return self._m_has_field_gv_fw_bullet_life_time self._m_has_field_gv_fw_bullet_life_time = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_gv_fw_bullet_life_time', None) @property def has_field_gv_fw_scale(self): if hasattr(self, '_m_has_field_gv_fw_scale'): return self._m_has_field_gv_fw_scale self._m_has_field_gv_fw_scale = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gv_fw_scale', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigBornDirectionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_angle_offset: self.angle_offset = Output.DynamicFloatVector(self._io, self, self._root) if self.has_field_angle_offset_correct: self.angle_offset_correct = Output.DynamicFloatVector(self._io, self, self._root) if self.has_field_use_correct_dir: self.use_correct_dir = self._io.read_u1() if self.has_field_random_angle_hor: self.random_angle_hor = self._io.read_f4le() if self.has_field_random_angle_ver: self.random_angle_ver = self._io.read_f4le() if self.has_field_max_angle_type: self.max_angle_type = Output.EnumDirectionAngleType(self._io, self, self._root) if self.has_field_max_angle: self.max_angle = self._io.read_f4le() @property def has_field_angle_offset(self): if hasattr(self, '_m_has_field_angle_offset'): return self._m_has_field_angle_offset self._m_has_field_angle_offset = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angle_offset', None) @property def has_field_max_angle(self): if hasattr(self, '_m_has_field_max_angle'): return self._m_has_field_max_angle self._m_has_field_max_angle = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_max_angle', None) @property def has_field_random_angle_hor(self): if hasattr(self, '_m_has_field_random_angle_hor'): return self._m_has_field_random_angle_hor self._m_has_field_random_angle_hor = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_angle_hor', None) @property def has_field_use_correct_dir(self): if hasattr(self, '_m_has_field_use_correct_dir'): return self._m_has_field_use_correct_dir self._m_has_field_use_correct_dir = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_correct_dir', None) @property def has_field_angle_offset_correct(self): if hasattr(self, '_m_has_field_angle_offset_correct'): return self._m_has_field_angle_offset_correct self._m_has_field_angle_offset_correct = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_angle_offset_correct', None) @property def has_field_max_angle_type(self): if hasattr(self, '_m_has_field_max_angle_type'): return self._m_has_field_max_angle_type self._m_has_field_max_angle_type = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_max_angle_type', None) @property def has_field_random_angle_ver(self): if hasattr(self, '_m_has_field_random_angle_ver'): return self._m_has_field_random_angle_ver self._m_has_field_random_angle_ver = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_random_angle_ver', None) class VoicePersonalityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRandomTalkScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_style_list: self.free_style_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_free_style_list(self): if hasattr(self, '_m_has_field_free_style_list'): return self._m_has_field_free_style_list self._m_has_field_free_style_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_free_style_list', None) class EnumFleurFairDungeonStatMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FleurFairDungeonStatMethod, self.data.value) return getattr(self, '_m_value', None) class ByCurTeamElementTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigWeatherArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_accurate_border: self.is_accurate_border = self._io.read_u1() if self.has_field_points: self.points = Output.ArrayOfPoint2dLengthU(self._io, self, self._root) if self.has_field_is_use_height_border: self.is_use_height_border = self._io.read_u1() if self.has_field_bottom: self.bottom = self._io.read_f4le() if self.has_field_top: self.top = self._io.read_f4le() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_bottom(self): if hasattr(self, '_m_has_field_bottom'): return self._m_has_field_bottom self._m_has_field_bottom = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_bottom', None) @property def has_field_points(self): if hasattr(self, '_m_has_field_points'): return self._m_has_field_points self._m_has_field_points = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_points', None) @property def has_field_top(self): if hasattr(self, '_m_has_field_top'): return self._m_has_field_top self._m_has_field_top = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_top', None) @property def has_field_is_accurate_border(self): if hasattr(self, '_m_has_field_is_accurate_border'): return self._m_has_field_is_accurate_border self._m_has_field_is_accurate_border = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_accurate_border', None) @property def has_field_is_use_height_border(self): if hasattr(self, '_m_has_field_is_use_height_border'): return self._m_has_field_is_use_height_border self._m_has_field_is_use_height_border = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_use_height_border', None) class BartenderBasicExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterAvatarUpExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id_list: self.avatar_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_avatar_id_list(self): if hasattr(self, '_m_has_field_avatar_id_list'): return self._m_has_field_avatar_id_list self._m_has_field_avatar_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_avatar_id_list', None) class DictOfAuxTypesStringConfigMonsterInitialPose(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigMonsterInitialPose(self._io, self, self._root)) class RoguelikeCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_label: self.label = Output.EnumRoguelikeCardLabel(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRoguelikeCardType(self._io, self, self._root) if self.has_field_related_rune_list: self.related_rune_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_related_element_list: self.related_element_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_effect_config: self.effect_config = Output.RoguelikeEffectExcelConfig(self._io, self, self._root) if self.has_field_is_clear_at_next_level: self.is_clear_at_next_level = self._io.read_u1() if self.has_field_is_dynamic_show: self.is_dynamic_show = self._io.read_u1() if self.has_field_card_name: self.card_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_desc: self.extra_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param_list: self.desc_param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_desc_param_superposition_list: self.desc_param_superposition_list = Output.ArrayOfU1LengthU(self._io, self, self._root) if self.has_field_desc_param_base_value_list: self.desc_param_base_value_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_desc_param_base_value_list(self): if hasattr(self, '_m_has_field_desc_param_base_value_list'): return self._m_has_field_desc_param_base_value_list self._m_has_field_desc_param_base_value_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_desc_param_base_value_list', None) @property def has_field_label(self): if hasattr(self, '_m_has_field_label'): return self._m_has_field_label self._m_has_field_label = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_label', None) @property def has_field_card_name(self): if hasattr(self, '_m_has_field_card_name'): return self._m_has_field_card_name self._m_has_field_card_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_card_name', None) @property def has_field_is_dynamic_show(self): if hasattr(self, '_m_has_field_is_dynamic_show'): return self._m_has_field_is_dynamic_show self._m_has_field_is_dynamic_show = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_dynamic_show', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_effect_config(self): if hasattr(self, '_m_has_field_effect_config'): return self._m_has_field_effect_config self._m_has_field_effect_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_effect_config', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_desc_param_superposition_list(self): if hasattr(self, '_m_has_field_desc_param_superposition_list'): return self._m_has_field_desc_param_superposition_list self._m_has_field_desc_param_superposition_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_desc_param_superposition_list', None) @property def has_field_desc_param_list(self): if hasattr(self, '_m_has_field_desc_param_list'): return self._m_has_field_desc_param_list self._m_has_field_desc_param_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_desc_param_list', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_related_rune_list(self): if hasattr(self, '_m_has_field_related_rune_list'): return self._m_has_field_related_rune_list self._m_has_field_related_rune_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_related_rune_list', None) @property def has_field_is_clear_at_next_level(self): if hasattr(self, '_m_has_field_is_clear_at_next_level'): return self._m_has_field_is_clear_at_next_level self._m_has_field_is_clear_at_next_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_clear_at_next_level', None) @property def has_field_related_element_list(self): if hasattr(self, '_m_has_field_related_element_list'): return self._m_has_field_related_element_list self._m_has_field_related_element_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_related_element_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_extra_desc(self): if hasattr(self, '_m_has_field_extra_desc'): return self._m_has_field_extra_desc self._m_has_field_extra_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_extra_desc', None) class RefreshIndexTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumHasShieldTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumHasShieldType(self._io, self, self._root)) class EnumSectrObjectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrObjectType, self.data.value) return getattr(self, '_m_value', None) class EnumDailyTaskFinishType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DailyTaskFinishType, self.data.value) return getattr(self, '_m_value', None) class CustomLevelComponentTypeConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRecord(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_camera_attach_point: self.camera_attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_deactive_node_list: self.deactive_node_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_actor_info_list: self.actor_info_list = Output.ArrayOfConfigRecordActorInfoLengthU(self._io, self, self._root) if self.has_field_frame_list: self.frame_list = Output.ArrayOfConfigRecordFrameLengthU(self._io, self, self._root) if self.has_field_target_frame_rate: self.target_frame_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_target_frame_rate(self): if hasattr(self, '_m_has_field_target_frame_rate'): return self._m_has_field_target_frame_rate self._m_has_field_target_frame_rate = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_target_frame_rate', None) @property def has_field_actor_info_list(self): if hasattr(self, '_m_has_field_actor_info_list'): return self._m_has_field_actor_info_list self._m_has_field_actor_info_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_actor_info_list', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_deactive_node_list(self): if hasattr(self, '_m_has_field_deactive_node_list'): return self._m_has_field_deactive_node_list self._m_has_field_deactive_node_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_deactive_node_list', None) @property def has_field_frame_list(self): if hasattr(self, '_m_has_field_frame_list'): return self._m_has_field_frame_list self._m_has_field_frame_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_frame_list', None) @property def has_field_camera_attach_point(self): if hasattr(self, '_m_has_field_camera_attach_point'): return self._m_has_field_camera_attach_point self._m_has_field_camera_attach_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camera_attach_point', None) class TeamResonanceCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarChangeSkillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_index: self.index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_priority: self.priority = Output.EnumSwitchSkillPriority(self._io, self, self._root) if self.has_field_aim_skill_id: self.aim_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_jump_skill_id: self.jump_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fly_skill_id: self.fly_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_change_on_add: self.change_on_add = self._io.read_u1() @property def has_field_change_on_add(self): if hasattr(self, '_m_has_field_change_on_add'): return self._m_has_field_change_on_add self._m_has_field_change_on_add = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_change_on_add', None) @property def has_field_jump_skill_id(self): if hasattr(self, '_m_has_field_jump_skill_id'): return self._m_has_field_jump_skill_id self._m_has_field_jump_skill_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_jump_skill_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_fly_skill_id(self): if hasattr(self, '_m_has_field_fly_skill_id'): return self._m_has_field_fly_skill_id self._m_has_field_fly_skill_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_fly_skill_id', None) @property def has_field_aim_skill_id(self): if hasattr(self, '_m_has_field_aim_skill_id'): return self._m_has_field_aim_skill_id self._m_has_field_aim_skill_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_aim_skill_id', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_index', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumTalentFilterCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalentFilterCond, self.data.value) return getattr(self, '_m_value', None) class CampExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumJsonClimateTypeArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumJsonClimateType(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) class RelationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioEventCullingRuleBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFirstSightAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class EnumVegetationInteractType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VegetationInteractType, self.data.value) return getattr(self, '_m_value', None) class CoopSubStartPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_interaction_id: self.coop_interaction_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_coop_interaction_id(self): if hasattr(self, '_m_has_field_coop_interaction_id'): return self._m_has_field_coop_interaction_id self._m_has_field_coop_interaction_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_coop_interaction_id', None) class BlossomOpenExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_level: self.open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_open_level(self): if hasattr(self, '_m_has_field_open_level'): return self._m_has_field_open_level self._m_has_field_open_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_level', None) class DungeonSubTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicUIntStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_uint_param: self.uint_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_uint_param(self): if hasattr(self, '_m_has_field_uint_param'): return self._m_has_field_uint_param self._m_has_field_uint_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_uint_param', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class DoBlinkByGlobalPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_position_key: self.position_key = AuxTypes.String(self._io, self, self._root) if self.has_field_direction_key: self.direction_key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_global_up: self.use_global_up = self._io.read_u1() @property def has_field_position_key(self): if hasattr(self, '_m_has_field_position_key'): return self._m_has_field_position_key self._m_has_field_position_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position_key', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_use_global_up(self): if hasattr(self, '_m_has_field_use_global_up'): return self._m_has_field_use_global_up self._m_has_field_use_global_up = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_global_up', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_direction_key(self): if hasattr(self, '_m_has_field_direction_key'): return self._m_has_field_direction_key self._m_has_field_direction_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_direction_key', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class AttachToGadgetStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_state: self.gadget_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_gadget_state(self): if hasattr(self, '_m_has_field_gadget_state'): return self._m_has_field_gadget_state self._m_has_field_gadget_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_state', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigGadgetUiExtraItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetUiBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_extra_id: self.extra_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def post_gadget_action_params(self): if hasattr(self, '_m_post_gadget_action_params'): return self._m_post_gadget_action_params self._m_post_gadget_action_params = self.base.post_gadget_action_params return getattr(self, '_m_post_gadget_action_params', None) @property def has_field_extra_id(self): if hasattr(self, '_m_has_field_extra_id'): return self._m_has_field_extra_id self._m_has_field_extra_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_extra_id', None) @property def on_touch(self): if hasattr(self, '_m_on_touch'): return self._m_on_touch self._m_on_touch = self.base.on_touch return getattr(self, '_m_on_touch', None) @property def confirm_dialog_title(self): if hasattr(self, '_m_confirm_dialog_title'): return self._m_confirm_dialog_title self._m_confirm_dialog_title = self.base.confirm_dialog_title return getattr(self, '_m_confirm_dialog_title', None) @property def touch_params(self): if hasattr(self, '_m_touch_params'): return self._m_touch_params self._m_touch_params = self.base.touch_params return getattr(self, '_m_touch_params', None) @property def item_type(self): if hasattr(self, '_m_item_type'): return self._m_item_type self._m_item_type = self.base.item_type return getattr(self, '_m_item_type', None) @property def confirm_dialog_content(self): if hasattr(self, '_m_confirm_dialog_content'): return self._m_confirm_dialog_content self._m_confirm_dialog_content = self.base.confirm_dialog_content return getattr(self, '_m_confirm_dialog_content', None) @property def gadget_ui_btn_cfg_path(self): if hasattr(self, '_m_gadget_ui_btn_cfg_path'): return self._m_gadget_ui_btn_cfg_path self._m_gadget_ui_btn_cfg_path = self.base.gadget_ui_btn_cfg_path return getattr(self, '_m_gadget_ui_btn_cfg_path', None) @property def need_dialog_confirm(self): if hasattr(self, '_m_need_dialog_confirm'): return self._m_need_dialog_confirm self._m_need_dialog_confirm = self.base.need_dialog_confirm return getattr(self, '_m_need_dialog_confirm', None) @property def group_name(self): if hasattr(self, '_m_group_name'): return self._m_group_name self._m_group_name = self.base.group_name return getattr(self, '_m_group_name', None) @property def ui_name(self): if hasattr(self, '_m_ui_name'): return self._m_ui_name self._m_ui_name = self.base.ui_name return getattr(self, '_m_ui_name', None) @property def icon(self): if hasattr(self, '_m_icon'): return self._m_icon self._m_icon = self.base.icon return getattr(self, '_m_icon', None) @property def show_comb_type(self): if hasattr(self, '_m_show_comb_type'): return self._m_show_comb_type self._m_show_comb_type = self.base.show_comb_type return getattr(self, '_m_show_comb_type', None) @property def show_cond_types(self): if hasattr(self, '_m_show_cond_types'): return self._m_show_cond_types self._m_show_cond_types = self.base.show_cond_types return getattr(self, '_m_show_cond_types', None) class TalkHeroTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiNerveSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_nerve_target_type: self.nerve_target_type = Output.EnumConfigAiNerveTargetType(self._io, self, self._root) if self.has_field_change_threat_target: self.change_threat_target = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_nerve_target_type(self): if hasattr(self, '_m_has_field_nerve_target_type'): return self._m_has_field_nerve_target_type self._m_has_field_nerve_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_nerve_target_type', None) @property def has_field_change_threat_target(self): if hasattr(self, '_m_has_field_change_threat_target'): return self._m_has_field_change_threat_target self._m_has_field_change_threat_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_change_threat_target', None) class LevelTagGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_tag_id_list: self.level_tag_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_level_tag_id_list(self): if hasattr(self, '_m_has_field_level_tag_id_list'): return self._m_has_field_level_tag_id_list self._m_has_field_level_tag_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_tag_id_list', None) class EnumTargetPositionAreaLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetPositionAreaLevel, self.data.value) return getattr(self, '_m_value', None) class EnableHitAutoRedirect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class BartenderTaskExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_parent_quest_id: self.parent_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_cond: self.unlock_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id1: self.avatar_id1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id2: self.avatar_id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id1(self): if hasattr(self, '_m_has_field_avatar_id1'): return self._m_has_field_avatar_id1 self._m_has_field_avatar_id1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_avatar_id1', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_avatar_id2(self): if hasattr(self, '_m_has_field_avatar_id2'): return self._m_has_field_avatar_id2 self._m_has_field_avatar_id2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_avatar_id2', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_unlock_cond(self): if hasattr(self, '_m_has_field_unlock_cond'): return self._m_has_field_unlock_cond self._m_has_field_unlock_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_cond', None) @property def has_field_parent_quest_id(self): if hasattr(self, '_m_has_field_parent_quest_id'): return self._m_has_field_parent_quest_id self._m_has_field_parent_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_parent_quest_id', None) class EnumProudSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProudSkillType, self.data.value) return getattr(self, '_m_value', None) class MultiBadmintonShootMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_interval: self.min_interval = self._io.read_f4le() if self.has_field_max_interval: self.max_interval = self._io.read_f4le() if self.has_field_extra_shoot_interval: self.extra_shoot_interval = self._io.read_f4le() if self.has_field_extra_shoot_tag: self.extra_shoot_tag = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_bullets: self.bullets = Output.ArrayOfMultiBadmintonBulletLengthU(self._io, self, self._root) if self.has_field_tres_bullet_id: self.tres_bullet_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_normal_bullet_id: self.normal_bullet_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trace_bullet_id: self.trace_bullet_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trace_target: self.trace_target = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_per_change_weight: self.per_change_weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def has_field_tres_bullet_id(self): if hasattr(self, '_m_has_field_tres_bullet_id'): return self._m_has_field_tres_bullet_id self._m_has_field_tres_bullet_id = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_tres_bullet_id', None) @property def has_field_trace_target(self): if hasattr(self, '_m_has_field_trace_target'): return self._m_has_field_trace_target self._m_has_field_trace_target = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_trace_target', None) @property def has_field_extra_shoot_tag(self): if hasattr(self, '_m_has_field_extra_shoot_tag'): return self._m_has_field_extra_shoot_tag self._m_has_field_extra_shoot_tag = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_extra_shoot_tag', None) @property def has_field_extra_shoot_interval(self): if hasattr(self, '_m_has_field_extra_shoot_interval'): return self._m_has_field_extra_shoot_interval self._m_has_field_extra_shoot_interval = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_extra_shoot_interval', None) @property def has_field_per_change_weight(self): if hasattr(self, '_m_has_field_per_change_weight'): return self._m_has_field_per_change_weight self._m_has_field_per_change_weight = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_per_change_weight', None) @property def has_field_normal_bullet_id(self): if hasattr(self, '_m_has_field_normal_bullet_id'): return self._m_has_field_normal_bullet_id self._m_has_field_normal_bullet_id = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_normal_bullet_id', None) @property def has_field_bullets(self): if hasattr(self, '_m_has_field_bullets'): return self._m_has_field_bullets self._m_has_field_bullets = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_bullets', None) @property def has_field_trace_bullet_id(self): if hasattr(self, '_m_has_field_trace_bullet_id'): return self._m_has_field_trace_bullet_id self._m_has_field_trace_bullet_id = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_trace_bullet_id', None) @property def has_field_min_interval(self): if hasattr(self, '_m_has_field_min_interval'): return self._m_has_field_min_interval self._m_has_field_min_interval = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_min_interval', None) @property def has_field_max_interval(self): if hasattr(self, '_m_has_field_max_interval'): return self._m_has_field_max_interval self._m_has_field_max_interval = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_max_interval', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_born', None) class ByElementReactionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_reaction_type: self.reaction_type = Output.EnumElementReactionType(self._io, self, self._root) @property def has_field_reaction_type(self): if hasattr(self, '_m_has_field_reaction_type'): return self._m_has_field_reaction_type self._m_has_field_reaction_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reaction_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MichiaeBattleSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumPileTagLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumPileTag(self._io, self, self._root)) class HomeWorldCustomFurnitureSlotExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_slot_name: self.slot_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_no_parts_tips: self.no_parts_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_get_parts_tips: self.get_parts_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_root_gadget_id_list: self.root_gadget_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_slot_identifier_path_list: self.slot_identifier_path_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_dependent_slot_id_list: self.dependent_slot_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_page_title: self.page_title = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_slot_select: self.effect_slot_select = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_parts_setup: self.effect_parts_setup = AuxTypes.String(self._io, self, self._root) if self.has_field_slot_id: self.slot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_optional_parts_id_list: self.optional_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_necessary: self.is_necessary = self._io.read_u1() if self.has_field_default_parts_id_list: self.default_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pass_part_id_list: self.pass_part_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_parts_id: self.init_parts_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_slot_id(self): if hasattr(self, '_m_has_field_slot_id'): return self._m_has_field_slot_id self._m_has_field_slot_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_slot_id', None) @property def has_field_get_parts_tips(self): if hasattr(self, '_m_has_field_get_parts_tips'): return self._m_has_field_get_parts_tips self._m_has_field_get_parts_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_get_parts_tips', None) @property def has_field_slot_identifier_path_list(self): if hasattr(self, '_m_has_field_slot_identifier_path_list'): return self._m_has_field_slot_identifier_path_list self._m_has_field_slot_identifier_path_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_slot_identifier_path_list', None) @property def has_field_page_title(self): if hasattr(self, '_m_has_field_page_title'): return self._m_has_field_page_title self._m_has_field_page_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_page_title', None) @property def has_field_dependent_slot_id_list(self): if hasattr(self, '_m_has_field_dependent_slot_id_list'): return self._m_has_field_dependent_slot_id_list self._m_has_field_dependent_slot_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_dependent_slot_id_list', None) @property def has_field_default_parts_id_list(self): if hasattr(self, '_m_has_field_default_parts_id_list'): return self._m_has_field_default_parts_id_list self._m_has_field_default_parts_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_default_parts_id_list', None) @property def has_field_root_gadget_id_list(self): if hasattr(self, '_m_has_field_root_gadget_id_list'): return self._m_has_field_root_gadget_id_list self._m_has_field_root_gadget_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_root_gadget_id_list', None) @property def has_field_optional_parts_id_list(self): if hasattr(self, '_m_has_field_optional_parts_id_list'): return self._m_has_field_optional_parts_id_list self._m_has_field_optional_parts_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_optional_parts_id_list', None) @property def has_field_init_parts_id(self): if hasattr(self, '_m_has_field_init_parts_id'): return self._m_has_field_init_parts_id self._m_has_field_init_parts_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_init_parts_id', None) @property def has_field_is_necessary(self): if hasattr(self, '_m_has_field_is_necessary'): return self._m_has_field_is_necessary self._m_has_field_is_necessary = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_is_necessary', None) @property def has_field_effect_slot_select(self): if hasattr(self, '_m_has_field_effect_slot_select'): return self._m_has_field_effect_slot_select self._m_has_field_effect_slot_select = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_effect_slot_select', None) @property def has_field_effect_parts_setup(self): if hasattr(self, '_m_has_field_effect_parts_setup'): return self._m_has_field_effect_parts_setup self._m_has_field_effect_parts_setup = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_effect_parts_setup', None) @property def has_field_pass_part_id_list(self): if hasattr(self, '_m_has_field_pass_part_id_list'): return self._m_has_field_pass_part_id_list self._m_has_field_pass_part_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_pass_part_id_list', None) @property def has_field_slot_name(self): if hasattr(self, '_m_has_field_slot_name'): return self._m_has_field_slot_name self._m_has_field_slot_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_slot_name', None) @property def has_field_no_parts_tips(self): if hasattr(self, '_m_has_field_no_parts_tips'): return self._m_has_field_no_parts_tips self._m_has_field_no_parts_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_no_parts_tips', None) class ConfigAudioMidi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_instruments: self.instruments = Output.DictOfAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigWwiseString(self._io, self, self._root) if self.has_field_freeplay_buttons: self.freeplay_buttons = Output.DictOfAuxTypesVlqBase128LeSAuxTypesVlqBase128LeS(self._io, self, self._root) if self.has_field_freeplay_timeout: self.freeplay_timeout = self._io.read_f4le() if self.has_field_freeplay_max_distance: self.freeplay_max_distance = self._io.read_f4le() @property def has_field_instruments(self): if hasattr(self, '_m_has_field_instruments'): return self._m_has_field_instruments self._m_has_field_instruments = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_instruments', None) @property def has_field_freeplay_buttons(self): if hasattr(self, '_m_has_field_freeplay_buttons'): return self._m_has_field_freeplay_buttons self._m_has_field_freeplay_buttons = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_freeplay_buttons', None) @property def has_field_freeplay_timeout(self): if hasattr(self, '_m_has_field_freeplay_timeout'): return self._m_has_field_freeplay_timeout self._m_has_field_freeplay_timeout = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_freeplay_timeout', None) @property def has_field_freeplay_max_distance(self): if hasattr(self, '_m_has_field_freeplay_max_distance'): return self._m_has_field_freeplay_max_distance self._m_has_field_freeplay_max_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_freeplay_max_distance', None) class SelectTargetsByLcTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class EnumShaderUseType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShaderUseType, self.data.value) return getattr(self, '_m_value', None) class ByEnergy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class SalvageChallengeDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumSalvagePlayType(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_point_config_id: self.player_point_config_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_boat_point_config_id: self.boat_point_config_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_vehicle_gadget_id: self.vehicle_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_ids: self.watcher_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_watcher_ids(self): if hasattr(self, '_m_has_field_watcher_ids'): return self._m_has_field_watcher_ids self._m_has_field_watcher_ids = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_watcher_ids', None) @property def has_field_player_point_config_id(self): if hasattr(self, '_m_has_field_player_point_config_id'): return self._m_has_field_player_point_config_id self._m_has_field_player_point_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_player_point_config_id', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_vehicle_gadget_id(self): if hasattr(self, '_m_has_field_vehicle_gadget_id'): return self._m_has_field_vehicle_gadget_id self._m_has_field_vehicle_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_vehicle_gadget_id', None) @property def has_field_boat_point_config_id(self): if hasattr(self, '_m_has_field_boat_point_config_id'): return self._m_has_field_boat_point_config_id self._m_has_field_boat_point_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_boat_point_config_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class BuffIconExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AnimatorBool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class CreateEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_owner_is_target: self.owner_is_target = self._io.read_u1() if self.has_field_owner_is: self.owner_is = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_prop_owner_is: self.prop_owner_is = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_life_by_owner_is_alive: self.life_by_owner_is_alive = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_check_ground: self.check_ground = Output.CheckGround(self._io, self, self._root) if self.has_field_sight_group_with_owner: self.sight_group_with_owner = self._io.read_u1() if self.has_field_is_peer_id_from_player: self.is_peer_id_from_player = self._io.read_u1() if self.has_field_life_by_owner_v2: self.life_by_owner_v2 = self._io.read_u1() if self.has_field_dont_kill_self_by_client_prediction: self.dont_kill_self_by_client_prediction = self._io.read_u1() @property def has_field_sight_group_with_owner(self): if hasattr(self, '_m_has_field_sight_group_with_owner'): return self._m_has_field_sight_group_with_owner self._m_has_field_sight_group_with_owner = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_sight_group_with_owner', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_owner_is(self): if hasattr(self, '_m_has_field_owner_is'): return self._m_has_field_owner_is self._m_has_field_owner_is = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_owner_is', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_check_ground(self): if hasattr(self, '_m_has_field_check_ground'): return self._m_has_field_check_ground self._m_has_field_check_ground = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_check_ground', None) @property def has_field_life_by_owner_v2(self): if hasattr(self, '_m_has_field_life_by_owner_v2'): return self._m_has_field_life_by_owner_v2 self._m_has_field_life_by_owner_v2 = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_life_by_owner_v2', None) @property def has_field_life_by_owner_is_alive(self): if hasattr(self, '_m_has_field_life_by_owner_is_alive'): return self._m_has_field_life_by_owner_is_alive self._m_has_field_life_by_owner_is_alive = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_life_by_owner_is_alive', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_is_peer_id_from_player(self): if hasattr(self, '_m_has_field_is_peer_id_from_player'): return self._m_has_field_is_peer_id_from_player self._m_has_field_is_peer_id_from_player = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_is_peer_id_from_player', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_dont_kill_self_by_client_prediction(self): if hasattr(self, '_m_has_field_dont_kill_self_by_client_prediction'): return self._m_has_field_dont_kill_self_by_client_prediction self._m_has_field_dont_kill_self_by_client_prediction = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_dont_kill_self_by_client_prediction', None) @property def has_field_prop_owner_is(self): if hasattr(self, '_m_has_field_prop_owner_is'): return self._m_has_field_prop_owner_is self._m_has_field_prop_owner_is = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_prop_owner_is', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_owner_is_target(self): if hasattr(self, '_m_has_field_owner_is_target'): return self._m_has_field_owner_is_target self._m_has_field_owner_is_target = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_owner_is_target', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_born', None) class ChannellerSlabPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReviveAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.HealHp(self._io, self, self._root) @property def amount_by_target_max_hp_ratio(self): if hasattr(self, '_m_amount_by_target_max_hp_ratio'): return self._m_amount_by_target_max_hp_ratio self._m_amount_by_target_max_hp_ratio = self.base.amount_by_target_max_hp_ratio return getattr(self, '_m_amount_by_target_max_hp_ratio', None) @property def mute_heal_effect(self): if hasattr(self, '_m_mute_heal_effect'): return self._m_mute_heal_effect self._m_mute_heal_effect = self.base.mute_heal_effect return getattr(self, '_m_mute_heal_effect', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def ignore_ability_property(self): if hasattr(self, '_m_ignore_ability_property'): return self._m_ignore_ability_property self._m_ignore_ability_property = self.base.ignore_ability_property return getattr(self, '_m_ignore_ability_property', None) @property def amount(self): if hasattr(self, '_m_amount'): return self._m_amount self._m_amount = self.base.amount return getattr(self, '_m_amount', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def heal_ratio(self): if hasattr(self, '_m_heal_ratio'): return self._m_heal_ratio self._m_heal_ratio = self.base.heal_ratio return getattr(self, '_m_heal_ratio', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def amount_by_caster_attack_ratio(self): if hasattr(self, '_m_amount_by_caster_attack_ratio'): return self._m_amount_by_caster_attack_ratio self._m_amount_by_caster_attack_ratio = self.base.amount_by_caster_attack_ratio return getattr(self, '_m_amount_by_caster_attack_ratio', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def amount_by_caster_max_hp_ratio(self): if hasattr(self, '_m_amount_by_caster_max_hp_ratio'): return self._m_amount_by_caster_max_hp_ratio self._m_amount_by_caster_max_hp_ratio = self.base.amount_by_caster_max_hp_ratio return getattr(self, '_m_amount_by_caster_max_hp_ratio', None) @property def amount_by_target_current_hp_ratio(self): if hasattr(self, '_m_amount_by_target_current_hp_ratio'): return self._m_amount_by_target_current_hp_ratio self._m_amount_by_target_current_hp_ratio = self.base.amount_by_target_current_hp_ratio return getattr(self, '_m_amount_by_target_current_hp_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DungeonEntryTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfNumberItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberItem(self._io, self, self._root)) class WinterCampRaceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChangePlayMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_play_mode: self.to_play_mode = Output.EnumPlayModeType(self._io, self, self._root) if self.has_field_authority_only: self.authority_only = self._io.read_u1() @property def has_field_to_play_mode(self): if hasattr(self, '_m_has_field_to_play_mode'): return self._m_has_field_to_play_mode self._m_has_field_to_play_mode = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_play_mode', None) @property def has_field_authority_only(self): if hasattr(self, '_m_has_field_authority_only'): return self._m_has_field_authority_only self._m_has_field_authority_only = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_authority_only', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class OpActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LevelGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_inst_id: self.map_inst_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_follow_move_attach_point: self.follow_move_attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_follow_move_target_instance_id: self.follow_move_target_instance_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_misc_unlock_show_cut_scene: self.gadget_misc_unlock_show_cut_scene = self._io.read_u1() if self.has_field_gadget_misc_chest_show_moment: self.gadget_misc_chest_show_moment = Output.EnumChestShowMoment(self._io, self, self._root) if self.has_field_gadget_misc_chest_show_ui_remind: self.gadget_misc_chest_show_ui_remind = Output.EnumChestShowUiRemind(self._io, self, self._root) if self.has_field_gadget_misc_chest_show_cts_type: self.gadget_misc_chest_show_cts_type = Output.EnumChestShowCutsceneType(self._io, self, self._root) if self.has_field_billboard_has_ui_bar: self.billboard_has_ui_bar = self._io.read_u1() if self.has_field_billboard_show_ui_bar_dis: self.billboard_show_ui_bar_dis = self._io.read_f4le() if self.has_field_billboard_hide_ui_bar_dis: self.billboard_hide_ui_bar_dis = self._io.read_f4le() if self.has_field_billboard_ui_bar_need_enter_combat: self.billboard_ui_bar_need_enter_combat = self._io.read_u1() if self.has_field_billboard_hp_bar_style: self.billboard_hp_bar_style = Output.EnumHpBarStyle(self._io, self, self._root) if self.has_field_target_indicator_type: self.target_indicator_type = Output.EnumTargetIndicatorType(self._io, self, self._root) if self.has_field_ui_indicator: self.ui_indicator = Output.ConfigTemplateData(self._io, self, self._root) if self.has_field_target_indicator_task_id: self.target_indicator_task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_billboard_multi_bar_sort_id: self.billboard_multi_bar_sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_billboard_multi_bar_num: self.billboard_multi_bar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger: self.trigger = Output.ConfigTriggerOverride(self._io, self, self._root) if self.has_field_follow_rotate_offset: self.follow_rotate_offset = Output.Vector(self._io, self, self._root) if self.has_field_follow_rotate_forward_offfset: self.follow_rotate_forward_offfset = Output.Vector(self._io, self, self._root) if self.has_field_entity_to_maneuver_city_map: self.entity_to_maneuver_city_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesString(self._io, self, self._root) if self.has_field_rotate_core_city_name: self.rotate_core_city_name = AuxTypes.String(self._io, self, self._root) @property def has_field_follow_rotate_forward_offfset(self): if hasattr(self, '_m_has_field_follow_rotate_forward_offfset'): return self._m_has_field_follow_rotate_forward_offfset self._m_has_field_follow_rotate_forward_offfset = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_follow_rotate_forward_offfset', None) @property def has_field_billboard_multi_bar_num(self): if hasattr(self, '_m_has_field_billboard_multi_bar_num'): return self._m_has_field_billboard_multi_bar_num self._m_has_field_billboard_multi_bar_num = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_billboard_multi_bar_num', None) @property def has_field_billboard_show_ui_bar_dis(self): if hasattr(self, '_m_has_field_billboard_show_ui_bar_dis'): return self._m_has_field_billboard_show_ui_bar_dis self._m_has_field_billboard_show_ui_bar_dis = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_billboard_show_ui_bar_dis', None) @property def has_field_billboard_hide_ui_bar_dis(self): if hasattr(self, '_m_has_field_billboard_hide_ui_bar_dis'): return self._m_has_field_billboard_hide_ui_bar_dis self._m_has_field_billboard_hide_ui_bar_dis = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_billboard_hide_ui_bar_dis', None) @property def has_field_follow_rotate_offset(self): if hasattr(self, '_m_has_field_follow_rotate_offset'): return self._m_has_field_follow_rotate_offset self._m_has_field_follow_rotate_offset = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_follow_rotate_offset', None) @property def has_field_billboard_has_ui_bar(self): if hasattr(self, '_m_has_field_billboard_has_ui_bar'): return self._m_has_field_billboard_has_ui_bar self._m_has_field_billboard_has_ui_bar = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_billboard_has_ui_bar', None) @property def has_field_gadget_misc_chest_show_cts_type(self): if hasattr(self, '_m_has_field_gadget_misc_chest_show_cts_type'): return self._m_has_field_gadget_misc_chest_show_cts_type self._m_has_field_gadget_misc_chest_show_cts_type = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_gadget_misc_chest_show_cts_type', None) @property def has_field_follow_move_attach_point(self): if hasattr(self, '_m_has_field_follow_move_attach_point'): return self._m_has_field_follow_move_attach_point self._m_has_field_follow_move_attach_point = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_follow_move_attach_point', None) @property def has_field_target_indicator_task_id(self): if hasattr(self, '_m_has_field_target_indicator_task_id'): return self._m_has_field_target_indicator_task_id self._m_has_field_target_indicator_task_id = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_target_indicator_task_id', None) @property def has_field_gadget_misc_chest_show_ui_remind(self): if hasattr(self, '_m_has_field_gadget_misc_chest_show_ui_remind'): return self._m_has_field_gadget_misc_chest_show_ui_remind self._m_has_field_gadget_misc_chest_show_ui_remind = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_gadget_misc_chest_show_ui_remind', None) @property def has_field_trigger(self): if hasattr(self, '_m_has_field_trigger'): return self._m_has_field_trigger self._m_has_field_trigger = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_trigger', None) @property def has_field_entity_to_maneuver_city_map(self): if hasattr(self, '_m_has_field_entity_to_maneuver_city_map'): return self._m_has_field_entity_to_maneuver_city_map self._m_has_field_entity_to_maneuver_city_map = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_entity_to_maneuver_city_map', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_billboard_multi_bar_sort_id(self): if hasattr(self, '_m_has_field_billboard_multi_bar_sort_id'): return self._m_has_field_billboard_multi_bar_sort_id self._m_has_field_billboard_multi_bar_sort_id = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_billboard_multi_bar_sort_id', None) @property def has_field_gadget_misc_chest_show_moment(self): if hasattr(self, '_m_has_field_gadget_misc_chest_show_moment'): return self._m_has_field_gadget_misc_chest_show_moment self._m_has_field_gadget_misc_chest_show_moment = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gadget_misc_chest_show_moment', None) @property def has_field_gadget_misc_unlock_show_cut_scene(self): if hasattr(self, '_m_has_field_gadget_misc_unlock_show_cut_scene'): return self._m_has_field_gadget_misc_unlock_show_cut_scene self._m_has_field_gadget_misc_unlock_show_cut_scene = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_gadget_misc_unlock_show_cut_scene', None) @property def has_field_target_indicator_type(self): if hasattr(self, '_m_has_field_target_indicator_type'): return self._m_has_field_target_indicator_type self._m_has_field_target_indicator_type = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_target_indicator_type', None) @property def has_field_billboard_hp_bar_style(self): if hasattr(self, '_m_has_field_billboard_hp_bar_style'): return self._m_has_field_billboard_hp_bar_style self._m_has_field_billboard_hp_bar_style = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_billboard_hp_bar_style', None) @property def has_field_follow_move_target_instance_id(self): if hasattr(self, '_m_has_field_follow_move_target_instance_id'): return self._m_has_field_follow_move_target_instance_id self._m_has_field_follow_move_target_instance_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_follow_move_target_instance_id', None) @property def has_field_map_inst_id(self): if hasattr(self, '_m_has_field_map_inst_id'): return self._m_has_field_map_inst_id self._m_has_field_map_inst_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_map_inst_id', None) @property def has_field_billboard_ui_bar_need_enter_combat(self): if hasattr(self, '_m_has_field_billboard_ui_bar_need_enter_combat'): return self._m_has_field_billboard_ui_bar_need_enter_combat self._m_has_field_billboard_ui_bar_need_enter_combat = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_billboard_ui_bar_need_enter_combat', None) @property def has_field_rotate_core_city_name(self): if hasattr(self, '_m_has_field_rotate_core_city_name'): return self._m_has_field_rotate_core_city_name self._m_has_field_rotate_core_city_name = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_rotate_core_city_name', None) @property def has_field_ui_indicator(self): if hasattr(self, '_m_has_field_ui_indicator'): return self._m_has_field_ui_indicator self._m_has_field_ui_indicator = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_ui_indicator', None) class QuestTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumControlPartDoOnUnEnabled(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ControlPartDoOnUnEnabled, self.data.value) return getattr(self, '_m_value', None) class AreaTerrainTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumElementReactionTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementReactionType(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class ByHaveMoveInput(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumCookFoodType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CookFoodType, self.data.value) return getattr(self, '_m_value', None) class ChangeFieldTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CombatEndCleanExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_combat_end_type: self.combat_end_type = Output.EnumCombatEndType(self._io, self, self._root) if self.has_field_modifier_tags: self.modifier_tags = Output.ArrayOfEnumModifierTagLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_combat_end_type(self): if hasattr(self, '_m_has_field_combat_end_type'): return self._m_has_field_combat_end_type self._m_has_field_combat_end_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_combat_end_type', None) @property def has_field_modifier_tags(self): if hasattr(self, '_m_has_field_modifier_tags'): return self._m_has_field_modifier_tags self._m_has_field_modifier_tags = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_modifier_tags', None) class ConfigGuidePageCheckBaseCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ForgeUnlockMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetGlobalValueToOverrideMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_formula: self.ability_formula = Output.EnumAbilityFormula(self._io, self, self._root) if self.has_field_is_from_owner: self.is_from_owner = self._io.read_u1() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_override_map_key: self.override_map_key = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_formula(self): if hasattr(self, '_m_has_field_ability_formula'): return self._m_has_field_ability_formula self._m_has_field_ability_formula = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_formula', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_map_key(self): if hasattr(self, '_m_has_field_override_map_key'): return self._m_has_field_override_map_key self._m_has_field_override_map_key = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_override_map_key', None) @property def has_field_is_from_owner(self): if hasattr(self, '_m_has_field_is_from_owner'): return self._m_has_field_is_from_owner self._m_has_field_is_from_owner = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_from_owner', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigInterActorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigInterActor(self._io, self, self._root)) class ActivityGearGadgetGearExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_radius: self.gear_radius = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_gear_tooth_count: self.gear_tooth_count = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_can_not_place_effect: self.gear_can_not_place_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_gear_place_effect: self.gear_place_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_cover_up_effect: self.cover_up_effect = AuxTypes.String(self._io, self, self._root) @property def has_field_gear_place_effect(self): if hasattr(self, '_m_has_field_gear_place_effect'): return self._m_has_field_gear_place_effect self._m_has_field_gear_place_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_gear_place_effect', None) @property def has_field_gear_radius(self): if hasattr(self, '_m_has_field_gear_radius'): return self._m_has_field_gear_radius self._m_has_field_gear_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gear_radius', None) @property def has_field_gear_can_not_place_effect(self): if hasattr(self, '_m_has_field_gear_can_not_place_effect'): return self._m_has_field_gear_can_not_place_effect self._m_has_field_gear_can_not_place_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_gear_can_not_place_effect', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_gear_tooth_count(self): if hasattr(self, '_m_has_field_gear_tooth_count'): return self._m_has_field_gear_tooth_count self._m_has_field_gear_tooth_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gear_tooth_count', None) @property def has_field_cover_up_effect(self): if hasattr(self, '_m_has_field_cover_up_effect'): return self._m_has_field_cover_up_effect self._m_has_field_cover_up_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cover_up_effect', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class MatchingTextDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByAny(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MultiplyGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_random_in_range: self.random_in_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def has_field_random_in_range(self): if hasattr(self, '_m_has_field_random_in_range'): return self._m_has_field_random_in_range self._m_has_field_random_in_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_in_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiMixinSetControllerCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pose_i_ds: self.pose_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_settings: self.settings = Output.ArrayOfConfigAiMixinSetControllerParameterLengthU(self._io, self, self._root) @property def has_field_pose_i_ds(self): if hasattr(self, '_m_has_field_pose_i_ds'): return self._m_has_field_pose_i_ds self._m_has_field_pose_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pose_i_ds', None) @property def has_field_settings(self): if hasattr(self, '_m_has_field_settings'): return self._m_has_field_settings self._m_has_field_settings = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_settings', None) class SetSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_special_camera_name: self.special_camera_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_special_camera_name(self): if hasattr(self, '_m_has_field_special_camera_name'): return self._m_has_field_special_camera_name self._m_has_field_special_camera_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_special_camera_name', None) class ConfigSoundBankLookup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_default_cooldown: self.default_cooldown = self._io.read_f4le() if self.has_field_unload_policies: self.unload_policies = Output.DictOfAuxTypesStringConfigSoundBankUnloadPolicy(self._io, self, self._root) if self.has_field_plain_events: self.plain_events = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bank_ids: self.bank_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_conditionals: self.conditionals = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bank_reuse_rate: self.bank_reuse_rate = self._io.read_f8le() if self.has_field_switch_groups_affected_by_rtpcs: self.switch_groups_affected_by_rtpcs = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_switch_groups_affected_by_events: self.switch_groups_affected_by_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_state_groups_affected_by_events: self.state_groups_affected_by_events = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_bank_reuse_rate(self): if hasattr(self, '_m_has_field_bank_reuse_rate'): return self._m_has_field_bank_reuse_rate self._m_has_field_bank_reuse_rate = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_bank_reuse_rate', None) @property def has_field_plain_events(self): if hasattr(self, '_m_has_field_plain_events'): return self._m_has_field_plain_events self._m_has_field_plain_events = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_plain_events', None) @property def has_field_state_groups_affected_by_events(self): if hasattr(self, '_m_has_field_state_groups_affected_by_events'): return self._m_has_field_state_groups_affected_by_events self._m_has_field_state_groups_affected_by_events = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_state_groups_affected_by_events', None) @property def has_field_bank_ids(self): if hasattr(self, '_m_has_field_bank_ids'): return self._m_has_field_bank_ids self._m_has_field_bank_ids = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_bank_ids', None) @property def has_field_default_cooldown(self): if hasattr(self, '_m_has_field_default_cooldown'): return self._m_has_field_default_cooldown self._m_has_field_default_cooldown = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_default_cooldown', None) @property def has_field_conditionals(self): if hasattr(self, '_m_has_field_conditionals'): return self._m_has_field_conditionals self._m_has_field_conditionals = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_conditionals', None) @property def has_field_switch_groups_affected_by_rtpcs(self): if hasattr(self, '_m_has_field_switch_groups_affected_by_rtpcs'): return self._m_has_field_switch_groups_affected_by_rtpcs self._m_has_field_switch_groups_affected_by_rtpcs = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_switch_groups_affected_by_rtpcs', None) @property def has_field_unload_policies(self): if hasattr(self, '_m_has_field_unload_policies'): return self._m_has_field_unload_policies self._m_has_field_unload_policies = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_unload_policies', None) @property def has_field_switch_groups_affected_by_events(self): if hasattr(self, '_m_has_field_switch_groups_affected_by_events'): return self._m_has_field_switch_groups_affected_by_events self._m_has_field_switch_groups_affected_by_events = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_switch_groups_affected_by_events', None) class CusmtomGadgetConfigIdExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_option_name: self.option_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_option_title: self.option_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_option_title(self): if hasattr(self, '_m_has_field_option_title'): return self._m_has_field_option_title self._m_has_field_option_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_option_title', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_option_name(self): if hasattr(self, '_m_has_field_option_name'): return self._m_has_field_option_name self._m_has_field_option_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_option_name', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_id', None) class GadgetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_has_move: self.has_move = self._io.read_u1() if self.has_field_has_audio: self.has_audio = self._io.read_u1() if self.has_field_is_equip: self.is_equip = self._io.read_u1() if self.has_field_is_interactive: self.is_interactive = self._io.read_u1() if self.has_field_vision_level: self.vision_level = Output.EnumVisionLevelType(self._io, self, self._root) if self.has_field_tags: self.tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_client_script_hash: self.client_script_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_client_script_hash: self.client_script_hash_pre = self._io.read_s1() if self.has_field_item_json_name: self.item_json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_item_prefab_path_hash: self.item_prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_prefab_path_hash: self.item_prefab_path_hash_pre = self._io.read_s1() if self.has_field_radar_hint_id: self.radar_hint_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intee_icon_name: self.intee_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_land_sound_id: self.land_sound_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_prop_id: self.mp_prop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_interact_name: self.interact_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chain_id: self.chain_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_dynamic_barrier: self.has_dynamic_barrier = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_pre = self._io.read_s1() if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_pre = self._io.read_s1() if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_pre = self._io.read_s1() if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_radar_hint_id(self): if hasattr(self, '_m_has_field_radar_hint_id'): return self._m_has_field_radar_hint_id self._m_has_field_radar_hint_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_radar_hint_id', None) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_camp_id', None) @property def has_field_is_interactive(self): if hasattr(self, '_m_has_field_is_interactive'): return self._m_has_field_is_interactive self._m_has_field_is_interactive = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_interactive', None) @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_tags', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_has_move(self): if hasattr(self, '_m_has_field_has_move'): return self._m_has_field_has_move self._m_has_field_has_move = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_has_move', None) @property def has_field_mp_prop_id(self): if hasattr(self, '_m_has_field_mp_prop_id'): return self._m_has_field_mp_prop_id self._m_has_field_mp_prop_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_mp_prop_id', None) @property def has_field_item_prefab_path_hash(self): if hasattr(self, '_m_has_field_item_prefab_path_hash'): return self._m_has_field_item_prefab_path_hash self._m_has_field_item_prefab_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_item_prefab_path_hash', None) @property def has_field_item_json_name(self): if hasattr(self, '_m_has_field_item_json_name'): return self._m_has_field_item_json_name self._m_has_field_item_json_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_item_json_name', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_client_script_hash(self): if hasattr(self, '_m_has_field_client_script_hash'): return self._m_has_field_client_script_hash self._m_has_field_client_script_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_client_script_hash', None) @property def has_field_has_dynamic_barrier(self): if hasattr(self, '_m_has_field_has_dynamic_barrier'): return self._m_has_field_has_dynamic_barrier self._m_has_field_has_dynamic_barrier = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_has_dynamic_barrier', None) @property def has_field_has_audio(self): if hasattr(self, '_m_has_field_has_audio'): return self._m_has_field_has_audio self._m_has_field_has_audio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_has_audio', None) @property def has_field_chain_id(self): if hasattr(self, '_m_has_field_chain_id'): return self._m_has_field_chain_id self._m_has_field_chain_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_chain_id', None) @property def has_field_land_sound_id(self): if hasattr(self, '_m_has_field_land_sound_id'): return self._m_has_field_land_sound_id self._m_has_field_land_sound_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_land_sound_id', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_intee_icon_name(self): if hasattr(self, '_m_has_field_intee_icon_name'): return self._m_has_field_intee_icon_name self._m_has_field_intee_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_intee_icon_name', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_is_equip(self): if hasattr(self, '_m_has_field_is_equip'): return self._m_has_field_is_equip self._m_has_field_is_equip = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_equip', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_interact_name(self): if hasattr(self, '_m_has_field_interact_name'): return self._m_has_field_interact_name self._m_has_field_interact_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_interact_name', None) @property def has_field_vision_level(self): if hasattr(self, '_m_has_field_vision_level'): return self._m_has_field_vision_level self._m_has_field_vision_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_vision_level', None) class DigAttachModifierToTargetDistanceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_id: self.target_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance: self.distance = self._io.read_f4le() if self.has_field_unfound_effect_pattern: self.unfound_effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_found_effect_pattern: self.found_effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_unfound_action_array: self.unfound_action_array = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_found_action_array: self.found_action_array = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_unfound_action_array(self): if hasattr(self, '_m_has_field_unfound_action_array'): return self._m_has_field_unfound_action_array self._m_has_field_unfound_action_array = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_unfound_action_array', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_distance', None) @property def has_field_target_id(self): if hasattr(self, '_m_has_field_target_id'): return self._m_has_field_target_id self._m_has_field_target_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_id', None) @property def has_field_found_effect_pattern(self): if hasattr(self, '_m_has_field_found_effect_pattern'): return self._m_has_field_found_effect_pattern self._m_has_field_found_effect_pattern = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_found_effect_pattern', None) @property def has_field_found_action_array(self): if hasattr(self, '_m_has_field_found_action_array'): return self._m_has_field_found_action_array self._m_has_field_found_action_array = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_found_action_array', None) @property def has_field_unfound_effect_pattern(self): if hasattr(self, '_m_has_field_unfound_effect_pattern'): return self._m_has_field_unfound_effect_pattern self._m_has_field_unfound_effect_pattern = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_unfound_effect_pattern', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class GivingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_id: self.talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mistake_talk_id: self.mistake_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab: self.tab = Output.EnumBagTab(self._io, self, self._root) if self.has_field_is_repeatable: self.is_repeatable = self._io.read_u1() if self.has_field_giving_method: self.giving_method = Output.EnumGivingMethod(self._io, self, self._root) if self.has_field_exact_items: self.exact_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_exact_finish_talk_id: self.exact_finish_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_giving_group_ids: self.giving_group_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_giving_group_count: self.giving_group_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_highlight: self.highlight = self._io.read_u1() if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_is_remove_item: self.is_remove_item = self._io.read_u1() if self.has_field_is_reset: self.is_reset = self._io.read_u1() if self.has_field_is_mp_enable: self.is_mp_enable = self._io.read_u1() if self.has_field_giving_type: self.giving_type = Output.EnumGivingType(self._io, self, self._root) if self.has_field_is_take_back: self.is_take_back = self._io.read_u1() @property def has_field_highlight(self): if hasattr(self, '_m_has_field_highlight'): return self._m_has_field_highlight self._m_has_field_highlight = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_highlight', None) @property def has_field_exact_finish_talk_id(self): if hasattr(self, '_m_has_field_exact_finish_talk_id'): return self._m_has_field_exact_finish_talk_id self._m_has_field_exact_finish_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_exact_finish_talk_id', None) @property def has_field_mistake_talk_id(self): if hasattr(self, '_m_has_field_mistake_talk_id'): return self._m_has_field_mistake_talk_id self._m_has_field_mistake_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_mistake_talk_id', None) @property def has_field_is_repeatable(self): if hasattr(self, '_m_has_field_is_repeatable'): return self._m_has_field_is_repeatable self._m_has_field_is_repeatable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_repeatable', None) @property def has_field_is_take_back(self): if hasattr(self, '_m_has_field_is_take_back'): return self._m_has_field_is_take_back self._m_has_field_is_take_back = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_is_take_back', None) @property def has_field_exact_items(self): if hasattr(self, '_m_has_field_exact_items'): return self._m_has_field_exact_items self._m_has_field_exact_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_exact_items', None) @property def has_field_tab(self): if hasattr(self, '_m_has_field_tab'): return self._m_has_field_tab self._m_has_field_tab = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tab', None) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_talk_id', None) @property def has_field_giving_group_ids(self): if hasattr(self, '_m_has_field_giving_group_ids'): return self._m_has_field_giving_group_ids self._m_has_field_giving_group_ids = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_giving_group_ids', None) @property def has_field_is_remove_item(self): if hasattr(self, '_m_has_field_is_remove_item'): return self._m_has_field_is_remove_item self._m_has_field_is_remove_item = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_remove_item', None) @property def has_field_giving_type(self): if hasattr(self, '_m_has_field_giving_type'): return self._m_has_field_giving_type self._m_has_field_giving_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_giving_type', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_is_reset(self): if hasattr(self, '_m_has_field_is_reset'): return self._m_has_field_is_reset self._m_has_field_is_reset = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_is_reset', None) @property def has_field_giving_group_count(self): if hasattr(self, '_m_has_field_giving_group_count'): return self._m_has_field_giving_group_count self._m_has_field_giving_group_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_giving_group_count', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_giving_method(self): if hasattr(self, '_m_has_field_giving_method'): return self._m_has_field_giving_method self._m_has_field_giving_method = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_giving_method', None) @property def has_field_is_mp_enable(self): if hasattr(self, '_m_has_field_is_mp_enable'): return self._m_has_field_is_mp_enable self._m_has_field_is_mp_enable = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_is_mp_enable', None) class EnumMusicGameParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MusicGameParam, self.data.value) return getattr(self, '_m_value', None) class ConfigWidgetCaptureAnimal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetUseAttachAbilityGroup(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_capture_tag_array: self.capture_tag_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_enter_codex: self.is_enter_codex = self._io.read_u1() if self.has_field_is_show_codex_entry: self.is_show_codex_entry = self._io.read_u1() @property def has_field_is_show_codex_entry(self): if hasattr(self, '_m_has_field_is_show_codex_entry'): return self._m_has_field_is_show_codex_entry self._m_has_field_is_show_codex_entry = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_show_codex_entry', None) @property def has_field_capture_tag_array(self): if hasattr(self, '_m_has_field_capture_tag_array'): return self._m_has_field_capture_tag_array self._m_has_field_capture_tag_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_capture_tag_array', None) @property def ability_group_name_second(self): if hasattr(self, '_m_ability_group_name_second'): return self._m_ability_group_name_second self._m_ability_group_name_second = self.base.ability_group_name_second return getattr(self, '_m_ability_group_name_second', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def ability_group_name(self): if hasattr(self, '_m_ability_group_name'): return self._m_ability_group_name self._m_ability_group_name = self.base.ability_group_name return getattr(self, '_m_ability_group_name', None) @property def is_update_cd_after_ability_trigger(self): if hasattr(self, '_m_is_update_cd_after_ability_trigger'): return self._m_is_update_cd_after_ability_trigger self._m_is_update_cd_after_ability_trigger = self.base.is_update_cd_after_ability_trigger return getattr(self, '_m_is_update_cd_after_ability_trigger', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_is_enter_codex(self): if hasattr(self, '_m_has_field_is_enter_codex'): return self._m_has_field_is_enter_codex self._m_has_field_is_enter_codex = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_enter_codex', None) @property def shared_cd_group(self): if hasattr(self, '_m_shared_cd_group'): return self._m_shared_cd_group self._m_shared_cd_group = self.base.shared_cd_group return getattr(self, '_m_shared_cd_group', None) @property def is_skip_take_off_ability_group_when_change_avatar(self): if hasattr(self, '_m_is_skip_take_off_ability_group_when_change_avatar'): return self._m_is_skip_take_off_ability_group_when_change_avatar self._m_is_skip_take_off_ability_group_when_change_avatar = self.base.is_skip_take_off_ability_group_when_change_avatar return getattr(self, '_m_is_skip_take_off_ability_group_when_change_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def replace_skill_hint_list(self): if hasattr(self, '_m_replace_skill_hint_list'): return self._m_replace_skill_hint_list self._m_replace_skill_hint_list = self.base.replace_skill_hint_list return getattr(self, '_m_replace_skill_hint_list', None) class AvatarLevelSkillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_index: self.skill_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_skill_index(self): if hasattr(self, '_m_has_field_skill_index'): return self._m_has_field_skill_index self._m_has_field_skill_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_index', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DebugBlletinInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_board_id: self.board_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.String(self._io, self, self._root) if self.has_field_author: self.author = AuxTypes.String(self._io, self, self._root) if self.has_field_create_time: self.create_time = AuxTypes.String(self._io, self, self._root) @property def has_field_author(self): if hasattr(self, '_m_has_field_author'): return self._m_has_field_author self._m_has_field_author = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_author', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_content', None) @property def has_field_board_id(self): if hasattr(self, '_m_has_field_board_id'): return self._m_has_field_board_id self._m_has_field_board_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_board_id', None) @property def has_field_create_time(self): if hasattr(self, '_m_has_field_create_time'): return self._m_has_field_create_time self._m_has_field_create_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_create_time', None) class EmoBackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispTileShapeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.TileShapeInfo(self._io, self, self._root) elif _on == 1: self.data = Output.SphereTileShapeInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivityPlantFlowerMainExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomQuestEntranceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_template_id: self.template_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_filter_logic_type: self.filter_logic_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_filter_list: self.filter_list = Output.ArrayOfRandomQuestFilterConfigLengthS(self._io, self, self._root) @property def has_field_template_id(self): if hasattr(self, '_m_has_field_template_id'): return self._m_has_field_template_id self._m_has_field_template_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_template_id', None) @property def has_field_filter_list(self): if hasattr(self, '_m_has_field_filter_list'): return self._m_has_field_filter_list self._m_has_field_filter_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_filter_list', None) @property def has_field_filter_logic_type(self): if hasattr(self, '_m_has_field_filter_logic_type'): return self._m_has_field_filter_logic_type self._m_has_field_filter_logic_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_filter_logic_type', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class Vector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_x: self.x = self._io.read_f4le() if self.has_field_y: self.y = self._io.read_f4le() if self.has_field_z: self.z = self._io.read_f4le() @property def has_field_x(self): if hasattr(self, '_m_has_field_x'): return self._m_has_field_x self._m_has_field_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_x', None) @property def has_field_y(self): if hasattr(self, '_m_has_field_y'): return self._m_has_field_y self._m_has_field_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y', None) @property def has_field_z(self): if hasattr(self, '_m_has_field_z'): return self._m_has_field_z self._m_has_field_z = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_z', None) class KvpOfDictAuxTypesStringDictOfAuxTypesStringAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) class ArrayOfAudioPlatformMoveSettingsLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioPlatformMoveSettings(self._io, self, self._root)) class EnumConfigGraphicSettingEntrySortType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigGraphicSettingEntrySortType, self.data.value) return getattr(self, '_m_value', None) class GuideOperatorComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumStrikeTypeConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumStrikeTypeConfigWwiseString(self._io, self, self._root)) class ArrayOfRoguelikeShikigamiUnlockConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RoguelikeShikigamiUnlockConfig(self._io, self, self._root)) class ConfigWaypoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_wait_time: self.wait_time = self._io.read_f4le() if self.has_field_move_angular_speed: self.move_angular_speed = self._io.read_f4le() if self.has_field_wait_angular_speed: self.wait_angular_speed = self._io.read_f4le() if self.has_field_move_rotate_round: self.move_rotate_round = self._io.read_f4le() if self.has_field_wait_rotate_round: self.wait_rotate_round = self._io.read_f4le() if self.has_field_stop_wait_rotate: self.stop_wait_rotate = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_target_velocity: self.target_velocity = self._io.read_f4le() if self.has_field_has_reach_event: self.has_reach_event = self._io.read_u1() if self.has_field_rot_angle_move_speed: self.rot_angle_move_speed = self._io.read_f4le() if self.has_field_rot_angle_wait_speed: self.rot_angle_wait_speed = self._io.read_f4le() if self.has_field_rot_angle_same_stop: self.rot_angle_same_stop = self._io.read_u1() if self.has_field_rot_round_reach_dir: self.rot_round_reach_dir = Output.Vector(self._io, self, self._root) if self.has_field_rot_round_reach_rounds: self.rot_round_reach_rounds = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_rot_round_leave_dir: self.rot_round_leave_dir = Output.Vector(self._io, self, self._root) if self.has_field_rot_round_wait_rounds: self.rot_round_wait_rounds = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_reach_stop: self.reach_stop = self._io.read_u1() @property def has_field_wait_rotate_round(self): if hasattr(self, '_m_has_field_wait_rotate_round'): return self._m_has_field_wait_rotate_round self._m_has_field_wait_rotate_round = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_wait_rotate_round', None) @property def has_field_rot_round_reach_rounds(self): if hasattr(self, '_m_has_field_rot_round_reach_rounds'): return self._m_has_field_rot_round_reach_rounds self._m_has_field_rot_round_reach_rounds = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_rot_round_reach_rounds', None) @property def has_field_rot_round_leave_dir(self): if hasattr(self, '_m_has_field_rot_round_leave_dir'): return self._m_has_field_rot_round_leave_dir self._m_has_field_rot_round_leave_dir = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_rot_round_leave_dir', None) @property def has_field_move_rotate_round(self): if hasattr(self, '_m_has_field_move_rotate_round'): return self._m_has_field_move_rotate_round self._m_has_field_move_rotate_round = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_move_rotate_round', None) @property def has_field_reach_stop(self): if hasattr(self, '_m_has_field_reach_stop'): return self._m_has_field_reach_stop self._m_has_field_reach_stop = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_reach_stop', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_wait_time(self): if hasattr(self, '_m_has_field_wait_time'): return self._m_has_field_wait_time self._m_has_field_wait_time = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_wait_time', None) @property def has_field_rot_angle_wait_speed(self): if hasattr(self, '_m_has_field_rot_angle_wait_speed'): return self._m_has_field_rot_angle_wait_speed self._m_has_field_rot_angle_wait_speed = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_rot_angle_wait_speed', None) @property def has_field_has_reach_event(self): if hasattr(self, '_m_has_field_has_reach_event'): return self._m_has_field_has_reach_event self._m_has_field_has_reach_event = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_has_reach_event', None) @property def has_field_wait_angular_speed(self): if hasattr(self, '_m_has_field_wait_angular_speed'): return self._m_has_field_wait_angular_speed self._m_has_field_wait_angular_speed = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_wait_angular_speed', None) @property def has_field_rot_round_wait_rounds(self): if hasattr(self, '_m_has_field_rot_round_wait_rounds'): return self._m_has_field_rot_round_wait_rounds self._m_has_field_rot_round_wait_rounds = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_rot_round_wait_rounds', None) @property def has_field_rot_angle_same_stop(self): if hasattr(self, '_m_has_field_rot_angle_same_stop'): return self._m_has_field_rot_angle_same_stop self._m_has_field_rot_angle_same_stop = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_rot_angle_same_stop', None) @property def has_field_rot_round_reach_dir(self): if hasattr(self, '_m_has_field_rot_round_reach_dir'): return self._m_has_field_rot_round_reach_dir self._m_has_field_rot_round_reach_dir = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_rot_round_reach_dir', None) @property def has_field_rot_angle_move_speed(self): if hasattr(self, '_m_has_field_rot_angle_move_speed'): return self._m_has_field_rot_angle_move_speed self._m_has_field_rot_angle_move_speed = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_rot_angle_move_speed', None) @property def has_field_target_velocity(self): if hasattr(self, '_m_has_field_target_velocity'): return self._m_has_field_target_velocity self._m_has_field_target_velocity = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_target_velocity', None) @property def has_field_move_angular_speed(self): if hasattr(self, '_m_has_field_move_angular_speed'): return self._m_has_field_move_angular_speed self._m_has_field_move_angular_speed = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_move_angular_speed', None) @property def has_field_stop_wait_rotate(self): if hasattr(self, '_m_has_field_stop_wait_rotate'): return self._m_has_field_stop_wait_rotate self._m_has_field_stop_wait_rotate = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_stop_wait_rotate', None) class ConfigElementShield(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_row: self.row = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_shield_damage_ratios_map: self.shield_damage_ratios_map = Output.DictOfEnumElementTypeConfigElementShieldResistance(self._io, self, self._root) @property def has_field_row(self): if hasattr(self, '_m_has_field_row'): return self._m_has_field_row self._m_has_field_row = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_row', None) @property def has_field_shield_damage_ratios_map(self): if hasattr(self, '_m_has_field_shield_damage_ratios_map'): return self._m_has_field_shield_damage_ratios_map self._m_has_field_shield_damage_ratios_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shield_damage_ratios_map', None) class ConfigBinaryCache(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHomeworldGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_group_units: self.group_units = Output.ArrayOfConfigHomeworldGroupUnitLengthU(self._io, self, self._root) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_group_units(self): if hasattr(self, '_m_has_field_group_units'): return self._m_has_field_group_units self._m_has_field_group_units = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_group_units', None) class AbilityOverrideParamConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_param_name: self.param_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param_value: self.param_value = self._io.read_f4le() @property def has_field_param_name(self): if hasattr(self, '_m_has_field_param_name'): return self._m_has_field_param_name self._m_has_field_param_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_param_name', None) @property def has_field_param_value(self): if hasattr(self, '_m_has_field_param_value'): return self._m_has_field_param_value self._m_has_field_param_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_value', None) class BonusActivityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldFurnitureTypeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_category_id: self.type_category_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_name: self.type_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_name2: self.type_name2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab_icon: self.tab_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_scene_type: self.scene_type = Output.EnumFurnitureDeployType(self._io, self, self._root) if self.has_field_camera_id: self.camera_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bag_page_only: self.bag_page_only = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_show_in_bag: self.is_show_in_bag = self._io.read_u1() if self.has_field_limit: self.limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_scene_type(self): if hasattr(self, '_m_has_field_scene_type'): return self._m_has_field_scene_type self._m_has_field_scene_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_scene_type', None) @property def has_field_type_name(self): if hasattr(self, '_m_has_field_type_name'): return self._m_has_field_type_name self._m_has_field_type_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_type_name', None) @property def has_field_is_show_in_bag(self): if hasattr(self, '_m_has_field_is_show_in_bag'): return self._m_has_field_is_show_in_bag self._m_has_field_is_show_in_bag = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_show_in_bag', None) @property def has_field_bag_page_only(self): if hasattr(self, '_m_has_field_bag_page_only'): return self._m_has_field_bag_page_only self._m_has_field_bag_page_only = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_bag_page_only', None) @property def has_field_limit(self): if hasattr(self, '_m_has_field_limit'): return self._m_has_field_limit self._m_has_field_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_limit', None) @property def has_field_tab_icon(self): if hasattr(self, '_m_has_field_tab_icon'): return self._m_has_field_tab_icon self._m_has_field_tab_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tab_icon', None) @property def has_field_type_name2(self): if hasattr(self, '_m_has_field_type_name2'): return self._m_has_field_type_name2 self._m_has_field_type_name2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type_name2', None) @property def has_field_camera_id(self): if hasattr(self, '_m_has_field_camera_id'): return self._m_has_field_camera_id self._m_has_field_camera_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_camera_id', None) @property def has_field_type_category_id(self): if hasattr(self, '_m_has_field_type_category_id'): return self._m_has_field_type_category_id self._m_has_field_type_category_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_category_id', None) class ArrayOfConfigActionPointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigActionPoint(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeUConfigWidgetCdGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigWidgetCdGroup(self._io, self, self._root)) class LockTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.String(self._io, self, self._root) if self.has_field_range: self.range = self._io.read_f4le() if self.has_field_combat_pri: self.combat_pri = self._io.read_f4le() if self.has_field_normal_pri: self.normal_pri = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_range', None) @property def has_field_combat_pri(self): if hasattr(self, '_m_has_field_combat_pri'): return self._m_has_field_combat_pri self._m_has_field_combat_pri = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_combat_pri', None) @property def has_field_normal_pri(self): if hasattr(self, '_m_has_field_normal_pri'): return self._m_has_field_normal_pri self._m_has_field_normal_pri = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_normal_pri', None) class ConfigGadgetConsoleOperation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_operation_name: self.operation_name = AuxTypes.String(self._io, self, self._root) if self.has_field_trans_name: self.trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_move_type: self.move_type = Output.EnumConfigGadgetConsoleOperationType(self._io, self, self._root) if self.has_field_move_speed: self.move_speed = self._io.read_f4le() if self.has_field_has_disable_value: self.has_disable_value = self._io.read_u1() if self.has_field_disable_value: self.disable_value = self._io.read_f4le() @property def has_field_trans_name(self): if hasattr(self, '_m_has_field_trans_name'): return self._m_has_field_trans_name self._m_has_field_trans_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trans_name', None) @property def has_field_operation_name(self): if hasattr(self, '_m_has_field_operation_name'): return self._m_has_field_operation_name self._m_has_field_operation_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_operation_name', None) @property def has_field_disable_value(self): if hasattr(self, '_m_has_field_disable_value'): return self._m_has_field_disable_value self._m_has_field_disable_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_disable_value', None) @property def has_field_has_disable_value(self): if hasattr(self, '_m_has_field_has_disable_value'): return self._m_has_field_has_disable_value self._m_has_field_has_disable_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_has_disable_value', None) @property def has_field_move_speed(self): if hasattr(self, '_m_has_field_move_speed'): return self._m_has_field_move_speed self._m_has_field_move_speed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_move_speed', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_move_type', None) class PaimonRequestFromComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerWeatherMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumTriggerWeatherType(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weather_pattern: self.weather_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_trans_duration: self.trans_duration = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_weather_pattern(self): if hasattr(self, '_m_has_field_weather_pattern'): return self._m_has_field_weather_pattern self._m_has_field_weather_pattern = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_weather_pattern', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_trans_duration(self): if hasattr(self, '_m_has_field_trans_duration'): return self._m_has_field_trans_duration self._m_has_field_trans_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_trans_duration', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WorldAreaLevelupConsumeItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_num: self.item_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_item_num(self): if hasattr(self, '_m_has_field_item_num'): return self._m_has_field_item_num self._m_has_field_item_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_num', None) class ConfigClimate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_common: self.common = Output.ConfigClimateCommon(self._io, self, self._root) if self.has_field_templates: self.templates = Output.DictOfAuxTypesStringDispConfigClimateInfoBase(self._io, self, self._root) @property def has_field_common(self): if hasattr(self, '_m_has_field_common'): return self._m_has_field_common self._m_has_field_common = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_common', None) @property def has_field_templates(self): if hasattr(self, '_m_has_field_templates'): return self._m_has_field_templates self._m_has_field_templates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_templates', None) class PersonalLineExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairMiniGameExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityChessLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp_to_next: self.exp_to_next = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_home_hp: self.home_hp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_initial_build: self.initial_build = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_count: self.card_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_cost: self.card_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_fortune: self.card_fortune = Output.EnumCardFortuneType(self._io, self, self._root) if self.has_field_fortune_list: self.fortune_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_free_card_count: self.free_card_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_new_gear_unlocked: self.is_new_gear_unlocked = self._io.read_u1() if self.has_field_is_new_card_unlocked: self.is_new_card_unlocked = self._io.read_u1() @property def has_field_home_hp(self): if hasattr(self, '_m_has_field_home_hp'): return self._m_has_field_home_hp self._m_has_field_home_hp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_home_hp', None) @property def has_field_card_fortune(self): if hasattr(self, '_m_has_field_card_fortune'): return self._m_has_field_card_fortune self._m_has_field_card_fortune = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_card_fortune', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_free_card_count(self): if hasattr(self, '_m_has_field_free_card_count'): return self._m_has_field_free_card_count self._m_has_field_free_card_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_free_card_count', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_initial_build(self): if hasattr(self, '_m_has_field_initial_build'): return self._m_has_field_initial_build self._m_has_field_initial_build = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_initial_build', None) @property def has_field_is_new_card_unlocked(self): if hasattr(self, '_m_has_field_is_new_card_unlocked'): return self._m_has_field_is_new_card_unlocked self._m_has_field_is_new_card_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_is_new_card_unlocked', None) @property def has_field_fortune_list(self): if hasattr(self, '_m_has_field_fortune_list'): return self._m_has_field_fortune_list self._m_has_field_fortune_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_fortune_list', None) @property def has_field_is_new_gear_unlocked(self): if hasattr(self, '_m_has_field_is_new_gear_unlocked'): return self._m_has_field_is_new_gear_unlocked self._m_has_field_is_new_gear_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_new_gear_unlocked', None) @property def has_field_card_cost(self): if hasattr(self, '_m_has_field_card_cost'): return self._m_has_field_card_cost self._m_has_field_card_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_card_cost', None) @property def has_field_card_count(self): if hasattr(self, '_m_has_field_card_count'): return self._m_has_field_card_count self._m_has_field_card_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_card_count', None) @property def has_field_exp_to_next(self): if hasattr(self, '_m_has_field_exp_to_next'): return self._m_has_field_exp_to_next self._m_has_field_exp_to_next = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_exp_to_next', None) class DispConfigMoveFollowTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigMoveFollowTarget(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigMoveFollowNpc(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigBuffDebuffResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_resistance_buff_debuffs: self.resistance_buff_debuffs = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) if self.has_field_resistance_ratio: self.resistance_ratio = self._io.read_f4le() if self.has_field_duration_ratio: self.duration_ratio = self._io.read_f4le() @property def has_field_resistance_buff_debuffs(self): if hasattr(self, '_m_has_field_resistance_buff_debuffs'): return self._m_has_field_resistance_buff_debuffs self._m_has_field_resistance_buff_debuffs = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_resistance_buff_debuffs', None) @property def has_field_resistance_ratio(self): if hasattr(self, '_m_has_field_resistance_ratio'): return self._m_has_field_resistance_ratio self._m_has_field_resistance_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_resistance_ratio', None) @property def has_field_duration_ratio(self): if hasattr(self, '_m_has_field_duration_ratio'): return self._m_has_field_duration_ratio self._m_has_field_duration_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration_ratio', None) class ServerUpdateGlobalValueMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class FightPropGrowConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_grow_curve: self.grow_curve = Output.EnumGrowCurveType(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_grow_curve(self): if hasattr(self, '_m_has_field_grow_curve'): return self._m_has_field_grow_curve self._m_has_field_grow_curve = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_grow_curve', None) class CommonPlayerTipsTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRaycastType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RaycastType, self.data.value) return getattr(self, '_m_value', None) class NewActivityScoreRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_score_tips: self.activity_score_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_score_extra_tips: self.activity_score_extra_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_activity_score_extra_tips(self): if hasattr(self, '_m_has_field_activity_score_extra_tips'): return self._m_has_field_activity_score_extra_tips self._m_has_field_activity_score_extra_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_activity_score_extra_tips', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_activity_score_tips(self): if hasattr(self, '_m_has_field_activity_score_tips'): return self._m_has_field_activity_score_tips self._m_has_field_activity_score_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_score_tips', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ExpeditionReward(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_htime: self.htime = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_drop_id: self.reward_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_htime(self): if hasattr(self, '_m_has_field_htime'): return self._m_has_field_htime self._m_has_field_htime = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_htime', None) @property def has_field_reward_drop_id(self): if hasattr(self, '_m_has_field_reward_drop_id'): return self._m_has_field_reward_drop_id self._m_has_field_reward_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_drop_id', None) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview', None) class ArrayOfHuntingRefreshCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.HuntingRefreshCond(self._io, self, self._root)) class ConfigMusicFixedTimeTransitions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_transitions: self.transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_fixed_time: self.fixed_time = self._io.read_f4le() @property def has_field_transitions(self): if hasattr(self, '_m_has_field_transitions'): return self._m_has_field_transitions self._m_has_field_transitions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_transitions', None) @property def has_field_fixed_time(self): if hasattr(self, '_m_has_field_fixed_time'): return self._m_has_field_fixed_time self._m_has_field_fixed_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fixed_time', None) class ReliquaryPowerupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumWeaponMaterialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WeaponMaterialType, self.data.value) return getattr(self, '_m_value', None) class AsterMidExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAvatarSpeechEquipObtainLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AvatarSpeechEquipObtain(self._io, self, self._root)) class ActivitySumoMonsterPreview(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_boss: self.boss = AuxTypes.String(self._io, self, self._root) if self.has_field_normal: self.normal = AuxTypes.String(self._io, self, self._root) @property def has_field_boss(self): if hasattr(self, '_m_has_field_boss'): return self._m_has_field_boss self._m_has_field_boss = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_boss', None) @property def has_field_normal(self): if hasattr(self, '_m_has_field_normal'): return self._m_has_field_normal self._m_has_field_normal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_normal', None) class EnumTriggerFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TriggerFlag, self.data.value) return getattr(self, '_m_value', None) class ConfigEmojiBubble(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfQuestCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestCond(self._io, self, self._root)) class QteExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BattlePassMissionRefreshTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityChessMapPointExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDungeonEntrySatisfiedCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DungeonEntrySatisfiedCond(self._io, self, self._root)) class PersonalLineActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfab_path: self.perfab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_feature: self.feature = Output.EnumPersonalLineActivityFeature(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_perfab_path(self): if hasattr(self, '_m_has_field_perfab_path'): return self._m_has_field_perfab_path self._m_has_field_perfab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_perfab_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_feature(self): if hasattr(self, '_m_has_field_feature'): return self._m_has_field_feature self._m_has_field_feature = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_feature', None) class ConfigBeHitBlendShakeByAinmator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBeHitBlendShake(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shake_flag_map: self.shake_flag_map = Output.ArrayOfShakeByAinmatorLengthU(self._io, self, self._root) @property def has_field_shake_flag_map(self): if hasattr(self, '_m_has_field_shake_flag_map'): return self._m_has_field_shake_flag_map self._m_has_field_shake_flag_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shake_flag_map', None) class SetSelfAttackTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_turn_to_target_immediately: self.turn_to_target_immediately = self._io.read_u1() if self.has_field_turn_to_target_keep_up_axis_direction: self.turn_to_target_keep_up_axis_direction = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_turn_to_target_immediately(self): if hasattr(self, '_m_has_field_turn_to_target_immediately'): return self._m_has_field_turn_to_target_immediately self._m_has_field_turn_to_target_immediately = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_turn_to_target_immediately', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_turn_to_target_keep_up_axis_direction(self): if hasattr(self, '_m_has_field_turn_to_target_keep_up_axis_direction'): return self._m_has_field_turn_to_target_keep_up_axis_direction self._m_has_field_turn_to_target_keep_up_axis_direction = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_to_target_keep_up_axis_direction', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringDispConfigClimateInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigClimateInfoBase(self._io, self, self._root) class ConfigPerfNumberArrayItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_device_spec_item: self.device_spec_item = Output.DictOfAuxTypesStringArrayOfF4LengthU(self._io, self, self._root) if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfNumberArrayItemOptionArrayInfo(self._io, self, self._root) if self.has_field_override_map: self.override_map = Output.DictOfAuxTypesStringConfigPerfNumberArrayItemOverrideInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def has_field_override_map(self): if hasattr(self, '_m_has_field_override_map'): return self._m_has_field_override_map self._m_has_field_override_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map', None) @property def has_field_device_spec_item(self): if hasattr(self, '_m_has_field_device_spec_item'): return self._m_has_field_device_spec_item self._m_has_field_device_spec_item = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_device_spec_item', None) class LunaRiteBattleBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_type: self.region_type = Output.EnumLunaRiteRegionType(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff: self.buff = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_number', None) @property def has_field_region_type(self): if hasattr(self, '_m_has_field_region_type'): return self._m_has_field_region_type self._m_has_field_region_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_region_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_buff(self): if hasattr(self, '_m_has_field_buff'): return self._m_has_field_buff self._m_has_field_buff = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_buff', None) class ConfigMusicUInt32listEmptinessCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class EnumTauntLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TauntLevel, self.data.value) return getattr(self, '_m_value', None) class EnumInvestigationMonsterMapMarkCreateConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InvestigationMonsterMapMarkCreateConditionType, self.data.value) return getattr(self, '_m_value', None) class EnumTaaQuality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TaaQuality, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumSummerTimeV2boatConditionTypeLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumSummerTimeV2boatConditionType(self._io, self, self._root)) class EffigyRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_grade: self.score_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_score_grade(self): if hasattr(self, '_m_has_field_score_grade'): return self._m_has_field_score_grade self._m_has_field_score_grade = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_score_grade', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) class ConfigSeal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_progress_type: self.progress_type = Output.EnumSealProgressType(self._io, self, self._root) if self.has_field_board_effect: self.board_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_board_effect_start_position: self.board_effect_start_position = self._io.read_f4le() if self.has_field_board_effect_end_position: self.board_effect_end_position = self._io.read_f4le() if self.has_field_start_tips: self.start_tips = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_board_effect(self): if hasattr(self, '_m_has_field_board_effect'): return self._m_has_field_board_effect self._m_has_field_board_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_board_effect', None) @property def has_field_board_effect_start_position(self): if hasattr(self, '_m_has_field_board_effect_start_position'): return self._m_has_field_board_effect_start_position self._m_has_field_board_effect_start_position = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_board_effect_start_position', None) @property def has_field_progress_type(self): if hasattr(self, '_m_has_field_progress_type'): return self._m_has_field_progress_type self._m_has_field_progress_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_progress_type', None) @property def has_field_board_effect_end_position(self): if hasattr(self, '_m_has_field_board_effect_end_position'): return self._m_has_field_board_effect_end_position self._m_has_field_board_effect_end_position = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_board_effect_end_position', None) @property def has_field_start_tips(self): if hasattr(self, '_m_has_field_start_tips'): return self._m_has_field_start_tips self._m_has_field_start_tips = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_start_tips', None) class ParticleShapeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideAvatarStateCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state: self.state = Output.EnumGuideAvatarState(self._io, self, self._root) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumQteStepButtonStyleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepButtonStyleType, self.data.value) return getattr(self, '_m_value', None) class ConfigSkiffMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigVehicleMove(self._io, self, self._root) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class PushTipsConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_subtitle: self.subtitle = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_type: self.push_tips_type = Output.EnumPushTipsType(self._io, self, self._root) if self.has_field_show_icon: self.show_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_tab_icon: self.tab_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_codex_type: self.codex_type = Output.EnumPushTipsCodexType(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_immediately: self.show_immediately = self._io.read_u1() @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_push_tips_type(self): if hasattr(self, '_m_has_field_push_tips_type'): return self._m_has_field_push_tips_type self._m_has_field_push_tips_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_push_tips_type', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_subtitle(self): if hasattr(self, '_m_has_field_subtitle'): return self._m_has_field_subtitle self._m_has_field_subtitle = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_subtitle', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_show_icon(self): if hasattr(self, '_m_has_field_show_icon'): return self._m_has_field_show_icon self._m_has_field_show_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_icon', None) @property def has_field_codex_type(self): if hasattr(self, '_m_has_field_codex_type'): return self._m_has_field_codex_type self._m_has_field_codex_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_codex_type', None) @property def has_field_show_immediately(self): if hasattr(self, '_m_has_field_show_immediately'): return self._m_has_field_show_immediately self._m_has_field_show_immediately = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_show_immediately', None) @property def has_field_tab_icon(self): if hasattr(self, '_m_has_field_tab_icon'): return self._m_has_field_tab_icon self._m_has_field_tab_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_tab_icon', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) class UseSkillEliteSet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_elite_set_id: self.skill_elite_set_id = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_skill_elite_set_id(self): if hasattr(self, '_m_has_field_skill_elite_set_id'): return self._m_has_field_skill_elite_set_id self._m_has_field_skill_elite_set_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_elite_set_id', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesStringConfigPlatformUiData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPlatformUiData(self._io, self, self._root)) class EnumExhibitionDisplayCondParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionDisplayCondParamType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigCrowdGroupInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdGroupInfo(self._io, self, self._root)) class ChestShowUiRemindComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root)) class MpPlayerSettleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHomeWorldFieldType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HomeWorldFieldType, self.data.value) return getattr(self, '_m_value', None) class StoryCameraPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UpdateReactionDamage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_level_target: self.level_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_reaction_damage_name: self.reaction_damage_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_level_target(self): if hasattr(self, '_m_has_field_level_target'): return self._m_has_field_level_target self._m_has_field_level_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level_target', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_reaction_damage_name(self): if hasattr(self, '_m_has_field_reaction_damage_name'): return self._m_has_field_reaction_damage_name self._m_has_field_reaction_damage_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reaction_damage_name', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class FishingAimParabolaMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_min_angle: self.min_angle = self._io.read_f4le() if self.has_field_max_angle: self.max_angle = self._io.read_f4le() if self.has_field_min_range: self.min_range = self._io.read_f4le() if self.has_field_max_range: self.max_range = self._io.read_f4le() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) @property def has_field_max_angle(self): if hasattr(self, '_m_has_field_max_angle'): return self._m_has_field_max_angle self._m_has_field_max_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_angle', None) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_max_range(self): if hasattr(self, '_m_has_field_max_range'): return self._m_has_field_max_range self._m_has_field_max_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_range', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_min_angle(self): if hasattr(self, '_m_has_field_min_angle'): return self._m_has_field_min_angle self._m_has_field_min_angle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_angle', None) @property def has_field_min_range(self): if hasattr(self, '_m_has_field_min_range'): return self._m_has_field_min_range self._m_has_field_min_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_range', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_target', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ProductIdConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClimateSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessMapPointExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetActiveExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumShopRecommendTabType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopRecommendTabType, self.data.value) return getattr(self, '_m_value', None) class ConfigDie(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_animator_die: self.has_animator_die = self._io.read_u1() if self.has_field_mute_all_shader_die_eff: self.mute_all_shader_die_eff = self._io.read_u1() if self.has_field_fall_when_air_die: self.fall_when_air_die = self._io.read_u1() if self.has_field_die_end_time: self.die_end_time = self._io.read_f4le() if self.has_field_die_force_disappear_time: self.die_force_disappear_time = self._io.read_f4le() if self.has_field_die_disappear_effect: self.die_disappear_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_die_disappear_effect_delay: self.die_disappear_effect_delay = self._io.read_f4le() if self.has_field_die_shader_data: self.die_shader_data = Output.EnumEShaderData(self._io, self, self._root) if self.has_field_die_shader_enable_duration_time: self.die_shader_enable_duration_time = self._io.read_f4le() if self.has_field_die_shader_disable_duration_time: self.die_shader_disable_duration_time = self._io.read_f4le() if self.has_field_die_model_fade_delay: self.die_model_fade_delay = self._io.read_f4le() if self.has_field_use_rag_doll: self.use_rag_doll = self._io.read_u1() if self.has_field_rag_doll_die_end_time_delay: self.rag_doll_die_end_time_delay = self._io.read_f4le() if self.has_field_start_die_end_at_once: self.start_die_end_at_once = self._io.read_u1() if self.has_field_not_send_die_trigger: self.not_send_die_trigger = self._io.read_u1() if self.has_field_ignore_element_die: self.ignore_element_die = self._io.read_u1() if self.has_field_mute_hit_box: self.mute_hit_box = self._io.read_u1() if self.has_field_die_deny_lock_on: self.die_deny_lock_on = self._io.read_u1() if self.has_field_die_is_ghost_to_enemy: self.die_is_ghost_to_enemy = self._io.read_u1() if self.has_field_die_ignore_trigger_bullet: self.die_ignore_trigger_bullet = self._io.read_u1() if self.has_field_mute_billboard: self.mute_billboard = self._io.read_u1() if self.has_field_mute_push_collider: self.mute_push_collider = self._io.read_u1() if self.has_field_drop_weapon_immediately: self.drop_weapon_immediately = self._io.read_u1() @property def has_field_die_model_fade_delay(self): if hasattr(self, '_m_has_field_die_model_fade_delay'): return self._m_has_field_die_model_fade_delay self._m_has_field_die_model_fade_delay = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_die_model_fade_delay', None) @property def has_field_die_deny_lock_on(self): if hasattr(self, '_m_has_field_die_deny_lock_on'): return self._m_has_field_die_deny_lock_on self._m_has_field_die_deny_lock_on = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_die_deny_lock_on', None) @property def has_field_die_is_ghost_to_enemy(self): if hasattr(self, '_m_has_field_die_is_ghost_to_enemy'): return self._m_has_field_die_is_ghost_to_enemy self._m_has_field_die_is_ghost_to_enemy = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_die_is_ghost_to_enemy', None) @property def has_field_die_shader_enable_duration_time(self): if hasattr(self, '_m_has_field_die_shader_enable_duration_time'): return self._m_has_field_die_shader_enable_duration_time self._m_has_field_die_shader_enable_duration_time = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_die_shader_enable_duration_time', None) @property def has_field_die_shader_disable_duration_time(self): if hasattr(self, '_m_has_field_die_shader_disable_duration_time'): return self._m_has_field_die_shader_disable_duration_time self._m_has_field_die_shader_disable_duration_time = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_die_shader_disable_duration_time', None) @property def has_field_start_die_end_at_once(self): if hasattr(self, '_m_has_field_start_die_end_at_once'): return self._m_has_field_start_die_end_at_once self._m_has_field_start_die_end_at_once = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_start_die_end_at_once', None) @property def has_field_die_force_disappear_time(self): if hasattr(self, '_m_has_field_die_force_disappear_time'): return self._m_has_field_die_force_disappear_time self._m_has_field_die_force_disappear_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_die_force_disappear_time', None) @property def has_field_not_send_die_trigger(self): if hasattr(self, '_m_has_field_not_send_die_trigger'): return self._m_has_field_not_send_die_trigger self._m_has_field_not_send_die_trigger = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_not_send_die_trigger', None) @property def has_field_has_animator_die(self): if hasattr(self, '_m_has_field_has_animator_die'): return self._m_has_field_has_animator_die self._m_has_field_has_animator_die = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_has_animator_die', None) @property def has_field_die_ignore_trigger_bullet(self): if hasattr(self, '_m_has_field_die_ignore_trigger_bullet'): return self._m_has_field_die_ignore_trigger_bullet self._m_has_field_die_ignore_trigger_bullet = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_die_ignore_trigger_bullet', None) @property def has_field_die_disappear_effect_delay(self): if hasattr(self, '_m_has_field_die_disappear_effect_delay'): return self._m_has_field_die_disappear_effect_delay self._m_has_field_die_disappear_effect_delay = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_die_disappear_effect_delay', None) @property def has_field_rag_doll_die_end_time_delay(self): if hasattr(self, '_m_has_field_rag_doll_die_end_time_delay'): return self._m_has_field_rag_doll_die_end_time_delay self._m_has_field_rag_doll_die_end_time_delay = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_rag_doll_die_end_time_delay', None) @property def has_field_drop_weapon_immediately(self): if hasattr(self, '_m_has_field_drop_weapon_immediately'): return self._m_has_field_drop_weapon_immediately self._m_has_field_drop_weapon_immediately = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_drop_weapon_immediately', None) @property def has_field_ignore_element_die(self): if hasattr(self, '_m_has_field_ignore_element_die'): return self._m_has_field_ignore_element_die self._m_has_field_ignore_element_die = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_ignore_element_die', None) @property def has_field_mute_billboard(self): if hasattr(self, '_m_has_field_mute_billboard'): return self._m_has_field_mute_billboard self._m_has_field_mute_billboard = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_mute_billboard', None) @property def has_field_die_end_time(self): if hasattr(self, '_m_has_field_die_end_time'): return self._m_has_field_die_end_time self._m_has_field_die_end_time = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_die_end_time', None) @property def has_field_mute_hit_box(self): if hasattr(self, '_m_has_field_mute_hit_box'): return self._m_has_field_mute_hit_box self._m_has_field_mute_hit_box = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_mute_hit_box', None) @property def has_field_mute_all_shader_die_eff(self): if hasattr(self, '_m_has_field_mute_all_shader_die_eff'): return self._m_has_field_mute_all_shader_die_eff self._m_has_field_mute_all_shader_die_eff = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_mute_all_shader_die_eff', None) @property def has_field_fall_when_air_die(self): if hasattr(self, '_m_has_field_fall_when_air_die'): return self._m_has_field_fall_when_air_die self._m_has_field_fall_when_air_die = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_fall_when_air_die', None) @property def has_field_use_rag_doll(self): if hasattr(self, '_m_has_field_use_rag_doll'): return self._m_has_field_use_rag_doll self._m_has_field_use_rag_doll = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_use_rag_doll', None) @property def has_field_die_disappear_effect(self): if hasattr(self, '_m_has_field_die_disappear_effect'): return self._m_has_field_die_disappear_effect self._m_has_field_die_disappear_effect = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_die_disappear_effect', None) @property def has_field_mute_push_collider(self): if hasattr(self, '_m_has_field_mute_push_collider'): return self._m_has_field_mute_push_collider self._m_has_field_mute_push_collider = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_mute_push_collider', None) @property def has_field_die_shader_data(self): if hasattr(self, '_m_has_field_die_shader_data'): return self._m_has_field_die_shader_data self._m_has_field_die_shader_data = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_die_shader_data', None) class CookBonusExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recipe_id: self.recipe_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_type: self.bonus_type = Output.EnumCookBonusType(self._io, self, self._root) if self.has_field_param_vec: self.param_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_complex_param_vec: self.complex_param_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_bonus_type(self): if hasattr(self, '_m_has_field_bonus_type'): return self._m_has_field_bonus_type self._m_has_field_bonus_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_bonus_type', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_recipe_id(self): if hasattr(self, '_m_has_field_recipe_id'): return self._m_has_field_recipe_id self._m_has_field_recipe_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_recipe_id', None) @property def has_field_param_vec(self): if hasattr(self, '_m_has_field_param_vec'): return self._m_has_field_param_vec self._m_has_field_param_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param_vec', None) @property def has_field_complex_param_vec(self): if hasattr(self, '_m_has_field_complex_param_vec'): return self._m_has_field_complex_param_vec self._m_has_field_complex_param_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_complex_param_vec', None) class FurnitureSuiteExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GraphicsSettingEntryTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAitsTargetBearingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiThreatScoreBaseSetting(self._io, self, self._root) @property def max(self): if hasattr(self, '_m_max'): return self._m_max self._m_max = self.base.max return getattr(self, '_m_max', None) @property def min(self): if hasattr(self, '_m_min'): return self._m_min self._m_min = self.base.min return getattr(self, '_m_min', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def compare_operation(self): if hasattr(self, '_m_compare_operation'): return self._m_compare_operation self._m_compare_operation = self.base.compare_operation return getattr(self, '_m_compare_operation', None) @property def weight(self): if hasattr(self, '_m_weight'): return self._m_weight self._m_weight = self.base.weight return getattr(self, '_m_weight', None) class EnumExhibitionScoreType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionScoreType, self.data.value) return getattr(self, '_m_value', None) class RogueDiaryRoundExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_room_count: self.room_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_round_room_config_list: self.round_room_config_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hp_correction: self.hp_correction = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_room_count(self): if hasattr(self, '_m_has_field_room_count'): return self._m_has_field_room_count self._m_has_field_room_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_room_count', None) @property def has_field_round_room_config_list(self): if hasattr(self, '_m_has_field_round_room_config_list'): return self._m_has_field_round_room_config_list self._m_has_field_round_room_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_round_room_config_list', None) @property def has_field_hp_correction(self): if hasattr(self, '_m_has_field_hp_correction'): return self._m_has_field_hp_correction self._m_has_field_hp_correction = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_hp_correction', None) class OpActivityBonusExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessDisorderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_disorder_id: self.disorder_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_disorder_id(self): if hasattr(self, '_m_has_field_disorder_id'): return self._m_has_field_disorder_id self._m_has_field_disorder_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_disorder_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) class EnumQteStepCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigCombatProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_endure_type: self.endure_type = Output.EnumEndureType(self._io, self, self._root) if self.has_field_use_creator_property: self.use_creator_property = self._io.read_u1() if self.has_field_use_creator_property_partly: self.use_creator_property_partly = Output.ArrayOfEnumCombatPropertyIndexLengthU(self._io, self, self._root) if self.has_field_use_creator_buffed_property: self.use_creator_buffed_property = self._io.read_u1() if self.has_field_use_ability_property: self.use_ability_property = self._io.read_u1() if self.has_field_hp: self.hp = self._io.read_f4le() if self.has_field_attack: self.attack = self._io.read_f4le() if self.has_field_defense: self.defense = self._io.read_f4le() if self.has_field_level: self.level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_level_option: self.level_option = Output.EnumLevelOption(self._io, self, self._root) if self.has_field_weight: self.weight = self._io.read_f4le() if self.has_field_endure_shake: self.endure_shake = self._io.read_f4le() if self.has_field_is_invincible: self.is_invincible = self._io.read_u1() if self.has_field_is_lock_hp: self.is_lock_hp = self._io.read_u1() if self.has_field_is_lock_hp_no_heal: self.is_lock_hp_no_heal = self._io.read_u1() if self.has_field_is_no_heal: self.is_no_heal = self._io.read_u1() if self.has_field_is_ghost_to_allied: self.is_ghost_to_allied = self._io.read_u1() if self.has_field_is_ghost_to_enemy: self.is_ghost_to_enemy = self._io.read_u1() if self.has_field_can_trigger_bullet: self.can_trigger_bullet = self._io.read_u1() if self.has_field_deny_element_stick: self.deny_element_stick = self._io.read_u1() if self.has_field_ignore_purge_rate: self.ignore_purge_rate = self._io.read_u1() if self.has_field_ignore_damage_to_self: self.ignore_damage_to_self = self._io.read_u1() @property def has_field_ignore_purge_rate(self): if hasattr(self, '_m_has_field_ignore_purge_rate'): return self._m_has_field_ignore_purge_rate self._m_has_field_ignore_purge_rate = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_ignore_purge_rate', None) @property def has_field_attack(self): if hasattr(self, '_m_has_field_attack'): return self._m_has_field_attack self._m_has_field_attack = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_attack', None) @property def has_field_use_ability_property(self): if hasattr(self, '_m_has_field_use_ability_property'): return self._m_has_field_use_ability_property self._m_has_field_use_ability_property = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_use_ability_property', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_use_creator_buffed_property(self): if hasattr(self, '_m_has_field_use_creator_buffed_property'): return self._m_has_field_use_creator_buffed_property self._m_has_field_use_creator_buffed_property = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_use_creator_buffed_property', None) @property def has_field_is_ghost_to_allied(self): if hasattr(self, '_m_has_field_is_ghost_to_allied'): return self._m_has_field_is_ghost_to_allied self._m_has_field_is_ghost_to_allied = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_is_ghost_to_allied', None) @property def has_field_ignore_damage_to_self(self): if hasattr(self, '_m_has_field_ignore_damage_to_self'): return self._m_has_field_ignore_damage_to_self self._m_has_field_ignore_damage_to_self = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_ignore_damage_to_self', None) @property def has_field_is_invincible(self): if hasattr(self, '_m_has_field_is_invincible'): return self._m_has_field_is_invincible self._m_has_field_is_invincible = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_is_invincible', None) @property def has_field_is_no_heal(self): if hasattr(self, '_m_has_field_is_no_heal'): return self._m_has_field_is_no_heal self._m_has_field_is_no_heal = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_is_no_heal', None) @property def has_field_endure_shake(self): if hasattr(self, '_m_has_field_endure_shake'): return self._m_has_field_endure_shake self._m_has_field_endure_shake = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_endure_shake', None) @property def has_field_defense(self): if hasattr(self, '_m_has_field_defense'): return self._m_has_field_defense self._m_has_field_defense = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_defense', None) @property def has_field_is_ghost_to_enemy(self): if hasattr(self, '_m_has_field_is_ghost_to_enemy'): return self._m_has_field_is_ghost_to_enemy self._m_has_field_is_ghost_to_enemy = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_is_ghost_to_enemy', None) @property def has_field_deny_element_stick(self): if hasattr(self, '_m_has_field_deny_element_stick'): return self._m_has_field_deny_element_stick self._m_has_field_deny_element_stick = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_deny_element_stick', None) @property def has_field_level_option(self): if hasattr(self, '_m_has_field_level_option'): return self._m_has_field_level_option self._m_has_field_level_option = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_level_option', None) @property def has_field_is_lock_hp(self): if hasattr(self, '_m_has_field_is_lock_hp'): return self._m_has_field_is_lock_hp self._m_has_field_is_lock_hp = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_is_lock_hp', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_is_lock_hp_no_heal(self): if hasattr(self, '_m_has_field_is_lock_hp_no_heal'): return self._m_has_field_is_lock_hp_no_heal self._m_has_field_is_lock_hp_no_heal = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_is_lock_hp_no_heal', None) @property def has_field_use_creator_property_partly(self): if hasattr(self, '_m_has_field_use_creator_property_partly'): return self._m_has_field_use_creator_property_partly self._m_has_field_use_creator_property_partly = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_use_creator_property_partly', None) @property def has_field_endure_type(self): if hasattr(self, '_m_has_field_endure_type'): return self._m_has_field_endure_type self._m_has_field_endure_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_endure_type', None) @property def has_field_hp(self): if hasattr(self, '_m_has_field_hp'): return self._m_has_field_hp self._m_has_field_hp = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_hp', None) @property def has_field_can_trigger_bullet(self): if hasattr(self, '_m_has_field_can_trigger_bullet'): return self._m_has_field_can_trigger_bullet self._m_has_field_can_trigger_bullet = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_can_trigger_bullet', None) @property def has_field_use_creator_property(self): if hasattr(self, '_m_has_field_use_creator_property'): return self._m_has_field_use_creator_property self._m_has_field_use_creator_property = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_use_creator_property', None) class EnumHuntingOfferDifficultyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingOfferDifficultyType, self.data.value) return getattr(self, '_m_value', None) class ConfigCompoundInputAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInputAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action1: self.action1 = Output.EnumInputActionType(self._io, self, self._root) if self.has_field_action2: self.action2 = Output.EnumInputActionType(self._io, self, self._root) if self.has_field_compound_type: self.compound_type = Output.EnumActionCompoundType(self._io, self, self._root) @property def has_field_action1(self): if hasattr(self, '_m_has_field_action1'): return self._m_has_field_action1 self._m_has_field_action1 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action1', None) @property def description_text_id(self): if hasattr(self, '_m_description_text_id'): return self._m_description_text_id self._m_description_text_id = self.base.description_text_id return getattr(self, '_m_description_text_id', None) @property def has_field_compound_type(self): if hasattr(self, '_m_has_field_compound_type'): return self._m_has_field_compound_type self._m_has_field_compound_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_compound_type', None) @property def value_type(self): if hasattr(self, '_m_value_type'): return self._m_value_type self._m_value_type = self.base.value_type return getattr(self, '_m_value_type', None) @property def has_field_action2(self): if hasattr(self, '_m_has_field_action2'): return self._m_has_field_action2 self._m_has_field_action2 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action2', None) class DispConfigLcBaseIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigLcBaseIntee(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLcGadgetIntee(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ByTargetConfigId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id_array: self.config_id_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_config_id_array(self): if hasattr(self, '_m_has_field_config_id_array'): return self._m_has_field_config_id_array self._m_has_field_config_id_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id_array', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfConfigAudioMapAreaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAudioMapArea(self._io, self, self._root)) class TriggerSetChestLock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_locked: self.locked = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_locked(self): if hasattr(self, '_m_has_field_locked'): return self._m_has_field_locked self._m_has_field_locked = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_locked', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.DictOfAuxTypesVlqBase128LeSConfigWwiseString(self._io, self, self._root) class ConfigPerfCombineItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_included_options: self.included_options = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) @property def has_field_included_options(self): if hasattr(self, '_m_has_field_included_options'): return self._m_has_field_included_options self._m_has_field_included_options = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_included_options', None) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class DictOfAuxTypesStringArrayOfEnumVoiceLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfEnumVoiceLanguageTypeLengthU(self._io, self, self._root)) class RoguelikeEffectExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumRoguelikeEffectType(self._io, self, self._root) if self.has_field_effect_key: self.effect_key = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_param: self.effect_param = AuxTypes.String(self._io, self, self._root) if self.has_field_display_offset: self.display_offset = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_effect_key(self): if hasattr(self, '_m_has_field_effect_key'): return self._m_has_field_effect_key self._m_has_field_effect_key = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_effect_key', None) @property def has_field_effect_param(self): if hasattr(self, '_m_has_field_effect_param'): return self._m_has_field_effect_param self._m_has_field_effect_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_effect_param', None) @property def has_field_display_offset(self): if hasattr(self, '_m_has_field_display_offset'): return self._m_has_field_display_offset self._m_has_field_display_offset = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_display_offset', None) class ConnectLineMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_repeater_modifier: self.repeater_modifier = AuxTypes.String(self._io, self, self._root) if self.has_field_collector_modifier: self.collector_modifier = AuxTypes.String(self._io, self, self._root) if self.has_field_collector_globalvalue_key: self.collector_globalvalue_key = AuxTypes.String(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_predicates_foreach: self.predicates_foreach = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_collector_modifier(self): if hasattr(self, '_m_has_field_collector_modifier'): return self._m_has_field_collector_modifier self._m_has_field_collector_modifier = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_collector_modifier', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_collector_globalvalue_key(self): if hasattr(self, '_m_has_field_collector_globalvalue_key'): return self._m_has_field_collector_globalvalue_key self._m_has_field_collector_globalvalue_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_collector_globalvalue_key', None) @property def has_field_predicates_foreach(self): if hasattr(self, '_m_has_field_predicates_foreach'): return self._m_has_field_predicates_foreach self._m_has_field_predicates_foreach = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_predicates_foreach', None) @property def has_field_repeater_modifier(self): if hasattr(self, '_m_has_field_repeater_modifier'): return self._m_has_field_repeater_modifier self._m_has_field_repeater_modifier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_repeater_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesVlqBase128LeSConfigAiSpacialFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialFacingMoveData(self._io, self, self._root)) class AnimatorInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ConfigWidgetAnchorPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invalid_scene_ids: self.invalid_scene_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def has_field_invalid_scene_ids(self): if hasattr(self, '_m_has_field_invalid_scene_ids'): return self._m_has_field_invalid_scene_ids self._m_has_field_invalid_scene_ids = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_invalid_scene_ids', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class ArrayOfTalkExecLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TalkExec(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeSConfigAiWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiWanderData(self._io, self, self._root)) class KvpOfDictEnumPerfRatingCategoryArrayOfConfigPerfRatingLevelLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPerfRatingCategory(self._io, self, self._root) self.value = Output.ArrayOfConfigPerfRatingLevelLengthU(self._io, self, self._root) class ConfigAuxObjectRegistryFullInspector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExhibitionCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_style: self.style = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_type: self.order_type = Output.EnumExhibitionCardOrderType(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_order_type(self): if hasattr(self, '_m_has_field_order_type'): return self._m_has_field_order_type self._m_has_field_order_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_order_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_style(self): if hasattr(self, '_m_has_field_style'): return self._m_has_field_style self._m_has_field_style = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_style', None) class AvatarFettersLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCustomAttackSphere(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_custom_attack_sphere_radius: self.custom_attack_sphere_radius = self._io.read_f4le() @property def has_field_custom_attack_sphere_radius(self): if hasattr(self, '_m_has_field_custom_attack_sphere_radius'): return self._m_has_field_custom_attack_sphere_radius self._m_has_field_custom_attack_sphere_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_attack_sphere_radius', None) class ConfigMatLinearChangedByDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_transform_name: self.transform_name = AuxTypes.String(self._io, self, self._root) if self.has_field_texture_property: self.texture_property = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_float_property: self.float_property = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_min_ratio: self.min_ratio = self._io.read_f4le() if self.has_field_max_ratio: self.max_ratio = self._io.read_f4le() if self.has_field_min_distance: self.min_distance = self._io.read_f4le() if self.has_field_max_distance: self.max_distance = self._io.read_f4le() @property def has_field_float_property(self): if hasattr(self, '_m_has_field_float_property'): return self._m_has_field_float_property self._m_has_field_float_property = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_float_property', None) @property def has_field_max_distance(self): if hasattr(self, '_m_has_field_max_distance'): return self._m_has_field_max_distance self._m_has_field_max_distance = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_max_distance', None) @property def has_field_min_distance(self): if hasattr(self, '_m_has_field_min_distance'): return self._m_has_field_min_distance self._m_has_field_min_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_min_distance', None) @property def has_field_min_ratio(self): if hasattr(self, '_m_has_field_min_ratio'): return self._m_has_field_min_ratio self._m_has_field_min_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_ratio', None) @property def has_field_transform_name(self): if hasattr(self, '_m_has_field_transform_name'): return self._m_has_field_transform_name self._m_has_field_transform_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_transform_name', None) @property def has_field_texture_property(self): if hasattr(self, '_m_has_field_texture_property'): return self._m_has_field_texture_property self._m_has_field_texture_property = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_texture_property', None) @property def has_field_max_ratio(self): if hasattr(self, '_m_has_field_max_ratio'): return self._m_has_field_max_ratio self._m_has_field_max_ratio = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_ratio', None) class DungeonCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PushTipsCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tip_id: self.push_tip_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_push_tip_id(self): if hasattr(self, '_m_has_field_push_tip_id'): return self._m_has_field_push_tip_id self._m_has_field_push_tip_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_push_tip_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_disuse', None) class BlinkHitSceneTestTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioMusic(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_group_name: self.state_group_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_casual_state_value: self.casual_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_combat_prep_state_value: self.combat_prep_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_combat_state_value: self.combat_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_peace_state_value: self.peace_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_city_approach_trigger: self.city_approach_trigger = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_combat_trigger: self.combat_trigger = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_combat_music_rtpc: self.combat_music_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_outer_enemy_concern_range: self.outer_enemy_concern_range = self._io.read_f4le() if self.has_field_inner_enemy_concern_range: self.inner_enemy_concern_range = self._io.read_f4le() if self.has_field_attack_from_behind_enter_distance: self.attack_from_behind_enter_distance = self._io.read_f4le() if self.has_field_attack_from_behind_exit_distance: self.attack_from_behind_exit_distance = self._io.read_f4le() if self.has_field_intention_in_front_product_threshold: self.intention_in_front_product_threshold = self._io.read_f4le() if self.has_field_intention_from_behind_product_threshold: self.intention_from_behind_product_threshold = self._io.read_f4le() if self.has_field_combat_rtpc_lower_bound: self.combat_rtpc_lower_bound = self._io.read_f4le() if self.has_field_combat_rtpc_upper_bound: self.combat_rtpc_upper_bound = self._io.read_f4le() if self.has_field_wait_frames_till_stage_mature: self.wait_frames_till_stage_mature = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_enemy_main_state_group: self.enemy_main_state_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_default_enemy_main_state_value: self.default_enemy_main_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enemy_settings: self.enemy_settings = Output.ArrayOfMusicEnemySettingsLengthU(self._io, self, self._root) if self.has_field_skiff_state_op: self.skiff_state_op = Output.AudioStateOp(self._io, self, self._root) @property def has_field_inner_enemy_concern_range(self): if hasattr(self, '_m_has_field_inner_enemy_concern_range'): return self._m_has_field_inner_enemy_concern_range self._m_has_field_inner_enemy_concern_range = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_inner_enemy_concern_range', None) @property def has_field_combat_rtpc_upper_bound(self): if hasattr(self, '_m_has_field_combat_rtpc_upper_bound'): return self._m_has_field_combat_rtpc_upper_bound self._m_has_field_combat_rtpc_upper_bound = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_combat_rtpc_upper_bound', None) @property def has_field_combat_prep_state_value(self): if hasattr(self, '_m_has_field_combat_prep_state_value'): return self._m_has_field_combat_prep_state_value self._m_has_field_combat_prep_state_value = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_combat_prep_state_value', None) @property def has_field_state_group_name(self): if hasattr(self, '_m_has_field_state_group_name'): return self._m_has_field_state_group_name self._m_has_field_state_group_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_state_group_name', None) @property def has_field_combat_trigger(self): if hasattr(self, '_m_has_field_combat_trigger'): return self._m_has_field_combat_trigger self._m_has_field_combat_trigger = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_combat_trigger', None) @property def has_field_attack_from_behind_exit_distance(self): if hasattr(self, '_m_has_field_attack_from_behind_exit_distance'): return self._m_has_field_attack_from_behind_exit_distance self._m_has_field_attack_from_behind_exit_distance = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_attack_from_behind_exit_distance', None) @property def has_field_enemy_main_state_group(self): if hasattr(self, '_m_has_field_enemy_main_state_group'): return self._m_has_field_enemy_main_state_group self._m_has_field_enemy_main_state_group = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_enemy_main_state_group', None) @property def has_field_combat_music_rtpc(self): if hasattr(self, '_m_has_field_combat_music_rtpc'): return self._m_has_field_combat_music_rtpc self._m_has_field_combat_music_rtpc = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_combat_music_rtpc', None) @property def has_field_attack_from_behind_enter_distance(self): if hasattr(self, '_m_has_field_attack_from_behind_enter_distance'): return self._m_has_field_attack_from_behind_enter_distance self._m_has_field_attack_from_behind_enter_distance = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_attack_from_behind_enter_distance', None) @property def has_field_outer_enemy_concern_range(self): if hasattr(self, '_m_has_field_outer_enemy_concern_range'): return self._m_has_field_outer_enemy_concern_range self._m_has_field_outer_enemy_concern_range = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_outer_enemy_concern_range', None) @property def has_field_peace_state_value(self): if hasattr(self, '_m_has_field_peace_state_value'): return self._m_has_field_peace_state_value self._m_has_field_peace_state_value = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_peace_state_value', None) @property def has_field_intention_in_front_product_threshold(self): if hasattr(self, '_m_has_field_intention_in_front_product_threshold'): return self._m_has_field_intention_in_front_product_threshold self._m_has_field_intention_in_front_product_threshold = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_intention_in_front_product_threshold', None) @property def has_field_intention_from_behind_product_threshold(self): if hasattr(self, '_m_has_field_intention_from_behind_product_threshold'): return self._m_has_field_intention_from_behind_product_threshold self._m_has_field_intention_from_behind_product_threshold = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_intention_from_behind_product_threshold', None) @property def has_field_city_approach_trigger(self): if hasattr(self, '_m_has_field_city_approach_trigger'): return self._m_has_field_city_approach_trigger self._m_has_field_city_approach_trigger = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_city_approach_trigger', None) @property def has_field_combat_rtpc_lower_bound(self): if hasattr(self, '_m_has_field_combat_rtpc_lower_bound'): return self._m_has_field_combat_rtpc_lower_bound self._m_has_field_combat_rtpc_lower_bound = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_combat_rtpc_lower_bound', None) @property def has_field_default_enemy_main_state_value(self): if hasattr(self, '_m_has_field_default_enemy_main_state_value'): return self._m_has_field_default_enemy_main_state_value self._m_has_field_default_enemy_main_state_value = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_default_enemy_main_state_value', None) @property def has_field_wait_frames_till_stage_mature(self): if hasattr(self, '_m_has_field_wait_frames_till_stage_mature'): return self._m_has_field_wait_frames_till_stage_mature self._m_has_field_wait_frames_till_stage_mature = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_wait_frames_till_stage_mature', None) @property def has_field_combat_state_value(self): if hasattr(self, '_m_has_field_combat_state_value'): return self._m_has_field_combat_state_value self._m_has_field_combat_state_value = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_combat_state_value', None) @property def has_field_enemy_settings(self): if hasattr(self, '_m_has_field_enemy_settings'): return self._m_has_field_enemy_settings self._m_has_field_enemy_settings = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_enemy_settings', None) @property def has_field_skiff_state_op(self): if hasattr(self, '_m_has_field_skiff_state_op'): return self._m_has_field_skiff_state_op self._m_has_field_skiff_state_op = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_skiff_state_op', None) @property def has_field_casual_state_value(self): if hasattr(self, '_m_has_field_casual_state_value'): return self._m_has_field_casual_state_value self._m_has_field_casual_state_value = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_casual_state_value', None) class ControlPartTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDirectionByBackToHitBoxCenter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class ConfigMusicBinaryCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lhs_id: self.lhs_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_rhs_id: self.rhs_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_lhs_id(self): if hasattr(self, '_m_has_field_lhs_id'): return self._m_has_field_lhs_id self._m_has_field_lhs_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lhs_id', None) @property def has_field_rhs_id(self): if hasattr(self, '_m_has_field_rhs_id'): return self._m_has_field_rhs_id self._m_has_field_rhs_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rhs_id', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class AttackHittingSceneMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_hitting_scene: self.on_hitting_scene = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_anim_event_i_ds: self.anim_event_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_on_hitting_scene(self): if hasattr(self, '_m_has_field_on_hitting_scene'): return self._m_has_field_on_hitting_scene self._m_has_field_on_hitting_scene = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_hitting_scene', None) @property def has_field_anim_event_i_ds(self): if hasattr(self, '_m_has_field_anim_event_i_ds'): return self._m_has_field_anim_event_i_ds self._m_has_field_anim_event_i_ds = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_anim_event_i_ds', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class AttachToStateIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_is_check_on_attach: self.is_check_on_attach = self._io.read_u1() @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_is_check_on_attach(self): if hasattr(self, '_m_has_field_is_check_on_attach'): return self._m_has_field_is_check_on_attach self._m_has_field_is_check_on_attach = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_check_on_attach', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlitzRushStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stage_title: self.stage_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_game_play_desc: self.game_play_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guidetask_desc: self.guidetask_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_game_play_desc(self): if hasattr(self, '_m_has_field_game_play_desc'): return self._m_has_field_game_play_desc self._m_has_field_game_play_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_game_play_desc', None) @property def has_field_guidetask_desc(self): if hasattr(self, '_m_has_field_guidetask_desc'): return self._m_has_field_guidetask_desc self._m_has_field_guidetask_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guidetask_desc', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_stage_title(self): if hasattr(self, '_m_has_field_stage_title'): return self._m_has_field_stage_title self._m_has_field_stage_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stage_title', None) class ConfigLevelGadgetData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadgets: self.gadgets = Output.ArrayOfLevelGadgetLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_gadgets(self): if hasattr(self, '_m_has_field_gadgets'): return self._m_has_field_gadgets self._m_has_field_gadgets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadgets', None) class CameraPlayCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_degree_x: self.degree_x = self._io.read_f4le() if self.has_field_degree_y: self.degree_y = self._io.read_f4le() if self.has_field_length: self.length = self._io.read_f4le() @property def has_field_degree_x(self): if hasattr(self, '_m_has_field_degree_x'): return self._m_has_field_degree_x self._m_has_field_degree_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_degree_x', None) @property def has_field_degree_y(self): if hasattr(self, '_m_has_field_degree_y'): return self._m_has_field_degree_y self._m_has_field_degree_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_degree_y', None) @property def has_field_length(self): if hasattr(self, '_m_has_field_length'): return self._m_has_field_length self._m_has_field_length = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_length', None) class AvatarExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RemoveServerBuff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_s_buff_id: self.s_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_team_buff: self.is_team_buff = self._io.read_u1() @property def has_field_is_team_buff(self): if hasattr(self, '_m_has_field_is_team_buff'): return self._m_has_field_is_team_buff self._m_has_field_is_team_buff = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_team_buff', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_s_buff_id(self): if hasattr(self, '_m_has_field_s_buff_id'): return self._m_has_field_s_buff_id self._m_has_field_s_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_s_buff_id', None) class ConfigDummyAbilityTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityTask(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dummy_number: self.dummy_number = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_dummy_number(self): if hasattr(self, '_m_has_field_dummy_number'): return self._m_has_field_dummy_number self._m_has_field_dummy_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dummy_number', None) @property def is_async(self): if hasattr(self, '_m_is_async'): return self._m_is_async self._m_is_async = self.base.is_async return getattr(self, '_m_is_async', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ActivityChessAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) class ChargeBarMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_charge_bar_element_type: self.charge_bar_element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_charge_bar_icon_id: self.charge_bar_icon_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_initial_value: self.initial_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_charge_bar_icon_id(self): if hasattr(self, '_m_has_field_charge_bar_icon_id'): return self._m_has_field_charge_bar_icon_id self._m_has_field_charge_bar_icon_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_charge_bar_icon_id', None) @property def has_field_initial_value(self): if hasattr(self, '_m_has_field_initial_value'): return self._m_has_field_initial_value self._m_has_field_initial_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_initial_value', None) @property def has_field_charge_bar_element_type(self): if hasattr(self, '_m_has_field_charge_bar_element_type'): return self._m_has_field_charge_bar_element_type self._m_has_field_charge_bar_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_charge_bar_element_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DispConfigLBaseMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigLBaseMark(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLMapMark(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class NativeArray(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicGamePositionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_inter_npcid: self.inter_npcid = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_position: self.npc_position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_npc_rotation: self.npc_rotation = self._io.read_f4le() if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_id: self.mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_style_id: self.free_style_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ban_config: self.ban_config = AuxTypes.String(self._io, self, self._root) @property def has_field_ban_config(self): if hasattr(self, '_m_has_field_ban_config'): return self._m_has_field_ban_config self._m_has_field_ban_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_ban_config', None) @property def has_field_free_style_id(self): if hasattr(self, '_m_has_field_free_style_id'): return self._m_has_field_free_style_id self._m_has_field_free_style_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_free_style_id', None) @property def has_field_mark_id(self): if hasattr(self, '_m_has_field_mark_id'): return self._m_has_field_mark_id self._m_has_field_mark_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mark_id', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_inter_npcid(self): if hasattr(self, '_m_has_field_inter_npcid'): return self._m_has_field_inter_npcid self._m_has_field_inter_npcid = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_inter_npcid', None) @property def has_field_npc_rotation(self): if hasattr(self, '_m_has_field_npc_rotation'): return self._m_has_field_npc_rotation self._m_has_field_npc_rotation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_npc_rotation', None) @property def has_field_npc_position(self): if hasattr(self, '_m_has_field_npc_position'): return self._m_has_field_npc_position self._m_has_field_npc_position = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_npc_position', None) class TalkRole(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumTalkRoleType(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) class SettleShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterMidDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumBodyMaterialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BodyMaterialType, self.data.value) return getattr(self, '_m_value', None) class GuideButtonClickComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAbilityGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ability_group_source_type: self.ability_group_source_type = Output.EnumAbilityGroupSourceType(self._io, self, self._root) if self.has_field_ability_group_target_type: self.ability_group_target_type = Output.EnumAbilityGroupTargetType(self._io, self, self._root) if self.has_field_ability_group_target_id_list: self.ability_group_target_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_target_abilities: self.target_abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_target_talents: self.target_talents = Output.ArrayOfConfigDynamicTalentLengthU(self._io, self, self._root) @property def has_field_ability_group_target_type(self): if hasattr(self, '_m_has_field_ability_group_target_type'): return self._m_has_field_ability_group_target_type self._m_has_field_ability_group_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_group_target_type', None) @property def has_field_ability_group_target_id_list(self): if hasattr(self, '_m_has_field_ability_group_target_id_list'): return self._m_has_field_ability_group_target_id_list self._m_has_field_ability_group_target_id_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_group_target_id_list', None) @property def has_field_target_talents(self): if hasattr(self, '_m_has_field_target_talents'): return self._m_has_field_target_talents self._m_has_field_target_talents = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_target_talents', None) @property def has_field_target_abilities(self): if hasattr(self, '_m_has_field_target_abilities'): return self._m_has_field_target_abilities self._m_has_field_target_abilities = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_target_abilities', None) @property def has_field_ability_group_source_type(self): if hasattr(self, '_m_has_field_ability_group_source_type'): return self._m_has_field_ability_group_source_type self._m_has_field_ability_group_source_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_source_type', None) class EffigyChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFallbackMarkTipsType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FallbackMarkTipsType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfTalkExecExLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TalkExecEx(self._io, self, self._root)) class ConfigAiCrabMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_radius_min: self.radius_min = self._io.read_f4le() if self.has_field_radius_max: self.radius_max = self._io.read_f4le() if self.has_field_move_time_min: self.move_time_min = self._io.read_f4le() if self.has_field_move_time_max: self.move_time_max = self._io.read_f4le() if self.has_field_rest_time_min: self.rest_time_min = self._io.read_f4le() if self.has_field_rest_time_max: self.rest_time_max = self._io.read_f4le() if self.has_field_detect_front_distance: self.detect_front_distance = self._io.read_f4le() @property def has_field_move_time_max(self): if hasattr(self, '_m_has_field_move_time_max'): return self._m_has_field_move_time_max self._m_has_field_move_time_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_move_time_max', None) @property def has_field_rest_time_max(self): if hasattr(self, '_m_has_field_rest_time_max'): return self._m_has_field_rest_time_max self._m_has_field_rest_time_max = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_rest_time_max', None) @property def has_field_rest_time_min(self): if hasattr(self, '_m_has_field_rest_time_min'): return self._m_has_field_rest_time_min self._m_has_field_rest_time_min = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_rest_time_min', None) @property def has_field_radius_min(self): if hasattr(self, '_m_has_field_radius_min'): return self._m_has_field_radius_min self._m_has_field_radius_min = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_radius_min', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_radius_max(self): if hasattr(self, '_m_has_field_radius_max'): return self._m_has_field_radius_max self._m_has_field_radius_max = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_radius_max', None) @property def has_field_move_time_min(self): if hasattr(self, '_m_has_field_move_time_min'): return self._m_has_field_move_time_min self._m_has_field_move_time_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_move_time_min', None) @property def has_field_detect_front_distance(self): if hasattr(self, '_m_has_field_detect_front_distance'): return self._m_has_field_detect_front_distance self._m_has_field_detect_front_distance = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_detect_front_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ArrayOfConfigEntityReuseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEntityReuse(self._io, self, self._root)) class DungeonMapAreaExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_area_id', None) class BonusTreasureSolutionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_image_hash: self.show_image_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_image_hash: self.show_image_hash_pre = self._io.read_s1() if self.has_field_solution: self.solution = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_image_hash(self): if hasattr(self, '_m_has_field_show_image_hash'): return self._m_has_field_show_image_hash self._m_has_field_show_image_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_show_image_hash', None) @property def has_field_solution(self): if hasattr(self, '_m_has_field_solution'): return self._m_has_field_solution self._m_has_field_solution = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_solution', None) class ConfigRuleCullingEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) class OverrideMonsterMoveSpeedRatioMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_min_value: self.min_value = self._io.read_f4le() if self.has_field_max_value: self.max_value = self._io.read_f4le() @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_value', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicSingleNoGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigQteStepBaseCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cond_type: self.cond_type = Output.EnumQteStepCondType(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cond_type', None) class EnumTalkMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkMarkType, self.data.value) return getattr(self, '_m_value', None) class ConfigSimulatePhysics(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) class ConfigLevelBlock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min: self.min = Output.Vector(self._io, self, self._root) if self.has_field_max: self.max = Output.Vector(self._io, self, self._root) if self.has_field_level_areas: self.level_areas = Output.ArrayOfConfigLevelAreaLengthU(self._io, self, self._root) @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max', None) @property def has_field_level_areas(self): if hasattr(self, '_m_has_field_level_areas'): return self._m_has_field_level_areas self._m_has_field_level_areas = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_level_areas', None) class WatcherPredicateConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_predicate_type: self.predicate_type = Output.EnumWatcherPredicateType(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_predicate_type(self): if hasattr(self, '_m_has_field_predicate_type'): return self._m_has_field_predicate_type self._m_has_field_predicate_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_predicate_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_list', None) class InvestigationConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_investigation_id_list: self.next_investigation_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_unlock_open_state_type: self.unlock_open_state_type = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_unlock_level: self.unlock_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_investigation_type: self.investigation_type = Output.EnumInvestigationType(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_next_investigation_id_list(self): if hasattr(self, '_m_has_field_next_investigation_id_list'): return self._m_has_field_next_investigation_id_list self._m_has_field_next_investigation_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_next_investigation_id_list', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_unlock_level(self): if hasattr(self, '_m_has_field_unlock_level'): return self._m_has_field_unlock_level self._m_has_field_unlock_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_unlock_open_state_type(self): if hasattr(self, '_m_has_field_unlock_open_state_type'): return self._m_has_field_unlock_open_state_type self._m_has_field_unlock_open_state_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_open_state_type', None) @property def has_field_investigation_type(self): if hasattr(self, '_m_has_field_investigation_type'): return self._m_has_field_investigation_type self._m_has_field_investigation_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_investigation_type', None) class EnumTextMapPlatformType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TextMapPlatformType, self.data.value) return getattr(self, '_m_value', None) class SumTargetWeightToSelfGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumGadgetUiItemShowCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetUiItemShowCondType, self.data.value) return getattr(self, '_m_value', None) class DictOfEnumNpcBodyTypeFirstPersonCoopCamConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumNpcBodyTypeFirstPersonCoopCamConfig(self._io, self, self._root)) class ConfigJudgeEntityInViewByEntityConfigId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scan_entity_list: self.scan_entity_list = Output.ArrayOfConfigJudgeEntityInViewDataLengthU(self._io, self, self._root) if self.has_field_scan_area_type: self.scan_area_type = Output.EnumScanAreaType(self._io, self, self._root) if self.has_field_width_ratio: self.width_ratio = self._io.read_f4le() if self.has_field_height_ratio: self.height_ratio = self._io.read_f4le() if self.has_field_scan_range_near_z: self.scan_range_near_z = self._io.read_f4le() if self.has_field_scan_range_far_z: self.scan_range_far_z = self._io.read_f4le() if self.has_field_scan_enable_ray_cast: self.scan_enable_ray_cast = self._io.read_u1() @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) @property def has_field_width_ratio(self): if hasattr(self, '_m_has_field_width_ratio'): return self._m_has_field_width_ratio self._m_has_field_width_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_width_ratio', None) @property def has_field_scan_range_near_z(self): if hasattr(self, '_m_has_field_scan_range_near_z'): return self._m_has_field_scan_range_near_z self._m_has_field_scan_range_near_z = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_scan_range_near_z', None) @property def has_field_scan_entity_list(self): if hasattr(self, '_m_has_field_scan_entity_list'): return self._m_has_field_scan_entity_list self._m_has_field_scan_entity_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scan_entity_list', None) @property def has_field_scan_enable_ray_cast(self): if hasattr(self, '_m_has_field_scan_enable_ray_cast'): return self._m_has_field_scan_enable_ray_cast self._m_has_field_scan_enable_ray_cast = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_scan_enable_ray_cast', None) @property def has_field_height_ratio(self): if hasattr(self, '_m_has_field_height_ratio'): return self._m_has_field_height_ratio self._m_has_field_height_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_height_ratio', None) @property def has_field_scan_range_far_z(self): if hasattr(self, '_m_has_field_scan_range_far_z'): return self._m_has_field_scan_range_far_z self._m_has_field_scan_range_far_z = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_scan_range_far_z', None) @property def has_field_scan_area_type(self): if hasattr(self, '_m_has_field_scan_area_type'): return self._m_has_field_scan_area_type self._m_has_field_scan_area_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scan_area_type', None) class TriggerExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_name: self.trigger_name = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_trigger_name(self): if hasattr(self, '_m_has_field_trigger_name'): return self._m_has_field_trigger_name self._m_has_field_trigger_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_trigger_name', None) class ConfigPerfNumberArrayItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfArrayOfF4LengthULengthU(self._io, self, self._root) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class PhotographTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_type: self.task_type = Output.EnumPhotographTaskType(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_x: self.center_x = self._io.read_f4le() if self.has_field_center_y: self.center_y = self._io.read_f4le() if self.has_field_center_z: self.center_z = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_target_gadget_id: self.target_gadget_id = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_start_time: self.start_time = self._io.read_f4le() if self.has_field_end_time: self.end_time = self._io.read_f4le() if self.has_field_questid: self.questid = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_tips: self.finish_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_tips: self.start_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_end_time(self): if hasattr(self, '_m_has_field_end_time'): return self._m_has_field_end_time self._m_has_field_end_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_end_time', None) @property def has_field_task_type(self): if hasattr(self, '_m_has_field_task_type'): return self._m_has_field_task_type self._m_has_field_task_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_task_type', None) @property def has_field_target_gadget_id(self): if hasattr(self, '_m_has_field_target_gadget_id'): return self._m_has_field_target_gadget_id self._m_has_field_target_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_target_gadget_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_center_y(self): if hasattr(self, '_m_has_field_center_y'): return self._m_has_field_center_y self._m_has_field_center_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_center_y', None) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_task_id', None) @property def has_field_center_x(self): if hasattr(self, '_m_has_field_center_x'): return self._m_has_field_center_x self._m_has_field_center_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_center_x', None) @property def has_field_finish_tips(self): if hasattr(self, '_m_has_field_finish_tips'): return self._m_has_field_finish_tips self._m_has_field_finish_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_finish_tips', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_radius', None) @property def has_field_questid(self): if hasattr(self, '_m_has_field_questid'): return self._m_has_field_questid self._m_has_field_questid = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_questid', None) @property def has_field_start_time(self): if hasattr(self, '_m_has_field_start_time'): return self._m_has_field_start_time self._m_has_field_start_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_start_time', None) @property def has_field_center_z(self): if hasattr(self, '_m_has_field_center_z'): return self._m_has_field_center_z self._m_has_field_center_z = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_center_z', None) @property def has_field_start_tips(self): if hasattr(self, '_m_has_field_start_tips'): return self._m_has_field_start_tips self._m_has_field_start_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_start_tips', None) class SceneSurfaceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AiPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_x: self.x = self._io.read_f4le() if self.has_field_y: self.y = self._io.read_f4le() @property def has_field_x(self): if hasattr(self, '_m_has_field_x'): return self._m_has_field_x self._m_has_field_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_x', None) @property def has_field_y(self): if hasattr(self, '_m_has_field_y'): return self._m_has_field_y self._m_has_field_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y', None) class ConfigLightAttach(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attach_point: self.attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_local_pos_x: self.local_pos_x = self._io.read_f4le() if self.has_field_local_pos_y: self.local_pos_y = self._io.read_f4le() if self.has_field_local_pos_z: self.local_pos_z = self._io.read_f4le() if self.has_field_local_rot_x: self.local_rot_x = self._io.read_f4le() if self.has_field_local_rot_y: self.local_rot_y = self._io.read_f4le() if self.has_field_local_rot_z: self.local_rot_z = self._io.read_f4le() if self.has_field_local_rot_w: self.local_rot_w = self._io.read_f4le() @property def has_field_local_pos_z(self): if hasattr(self, '_m_has_field_local_pos_z'): return self._m_has_field_local_pos_z self._m_has_field_local_pos_z = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_local_pos_z', None) @property def has_field_attach_point(self): if hasattr(self, '_m_has_field_attach_point'): return self._m_has_field_attach_point self._m_has_field_attach_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_point', None) @property def has_field_local_pos_x(self): if hasattr(self, '_m_has_field_local_pos_x'): return self._m_has_field_local_pos_x self._m_has_field_local_pos_x = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_local_pos_x', None) @property def has_field_local_pos_y(self): if hasattr(self, '_m_has_field_local_pos_y'): return self._m_has_field_local_pos_y self._m_has_field_local_pos_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_local_pos_y', None) @property def has_field_local_rot_x(self): if hasattr(self, '_m_has_field_local_rot_x'): return self._m_has_field_local_rot_x self._m_has_field_local_rot_x = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_local_rot_x', None) @property def has_field_local_rot_w(self): if hasattr(self, '_m_has_field_local_rot_w'): return self._m_has_field_local_rot_w self._m_has_field_local_rot_w = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_local_rot_w', None) @property def has_field_local_rot_z(self): if hasattr(self, '_m_has_field_local_rot_z'): return self._m_has_field_local_rot_z self._m_has_field_local_rot_z = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_local_rot_z', None) @property def has_field_local_rot_y(self): if hasattr(self, '_m_has_field_local_rot_y'): return self._m_has_field_local_rot_y self._m_has_field_local_rot_y = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_local_rot_y', None) class ActivityIslandPartyScoreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioSettingSlider(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_rtpc: self.rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_text_map: self.text_map = AuxTypes.String(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_each_values: self.each_values = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_each_values(self): if hasattr(self, '_m_has_field_each_values'): return self._m_has_field_each_values self._m_has_field_each_values = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_each_values', None) @property def has_field_rtpc(self): if hasattr(self, '_m_has_field_rtpc'): return self._m_has_field_rtpc self._m_has_field_rtpc = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_rtpc', None) @property def has_field_text_map(self): if hasattr(self, '_m_has_field_text_map'): return self._m_has_field_text_map self._m_has_field_text_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_text_map', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_value', None) class ConfigAiGroupSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_start_distance: self.start_distance = self._io.read_f4le() if self.has_field_surround_radius: self.surround_radius = self._io.read_f4le() if self.has_field_turning_states: self.turning_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_detect_front_distance: self.detect_front_distance = self._io.read_f4le() if self.has_field_detect_front_offset_up: self.detect_front_offset_up = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_exit_distance_max: self.exit_distance_max = self._io.read_f4le() if self.has_field_exit_distance_min: self.exit_distance_min = self._io.read_f4le() if self.has_field_clock_wise_weight: self.clock_wise_weight = self._io.read_f4le() if self.has_field_detect_collision_radius: self.detect_collision_radius = self._io.read_f4le() if self.has_field_detect_collision_distance: self.detect_collision_distance = self._io.read_f4le() @property def has_field_detect_front_offset_up(self): if hasattr(self, '_m_has_field_detect_front_offset_up'): return self._m_has_field_detect_front_offset_up self._m_has_field_detect_front_offset_up = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_detect_front_offset_up', None) @property def has_field_detect_collision_distance(self): if hasattr(self, '_m_has_field_detect_collision_distance'): return self._m_has_field_detect_collision_distance self._m_has_field_detect_collision_distance = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_detect_collision_distance', None) @property def has_field_turning_states(self): if hasattr(self, '_m_has_field_turning_states'): return self._m_has_field_turning_states self._m_has_field_turning_states = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_turning_states', None) @property def has_field_exit_distance_min(self): if hasattr(self, '_m_has_field_exit_distance_min'): return self._m_has_field_exit_distance_min self._m_has_field_exit_distance_min = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_exit_distance_min', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_exit_distance_max(self): if hasattr(self, '_m_has_field_exit_distance_max'): return self._m_has_field_exit_distance_max self._m_has_field_exit_distance_max = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_exit_distance_max', None) @property def has_field_surround_radius(self): if hasattr(self, '_m_has_field_surround_radius'): return self._m_has_field_surround_radius self._m_has_field_surround_radius = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_surround_radius', None) @property def has_field_detect_collision_radius(self): if hasattr(self, '_m_has_field_detect_collision_radius'): return self._m_has_field_detect_collision_radius self._m_has_field_detect_collision_radius = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_detect_collision_radius', None) @property def has_field_clock_wise_weight(self): if hasattr(self, '_m_has_field_clock_wise_weight'): return self._m_has_field_clock_wise_weight self._m_has_field_clock_wise_weight = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_clock_wise_weight', None) @property def has_field_start_distance(self): if hasattr(self, '_m_has_field_start_distance'): return self._m_has_field_start_distance self._m_has_field_start_distance = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_start_distance', None) @property def has_field_detect_front_distance(self): if hasattr(self, '_m_has_field_detect_front_distance'): return self._m_has_field_detect_front_distance self._m_has_field_detect_front_distance = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_detect_front_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class EnumAvatarUseType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AvatarUseType, self.data.value) return getattr(self, '_m_value', None) class BartenderAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DragonSpineMissionFinishExecTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigVodIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_excel_config_id: self.excel_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_excel_config_id(self): if hasattr(self, '_m_has_field_excel_config_id'): return self._m_has_field_excel_config_id self._m_has_field_excel_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_excel_config_id', None) class DictOfAuxTypesStringConfigSkipUnindexedEffectCreation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigSkipUnindexedEffectCreation(self._io, self, self._root)) class ConfigGadgetCollidedPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_collision_actions: self.collision_actions = Output.ArrayOfDispConfigBaseGadgetTriggerActionLengthU(self._io, self, self._root) if self.has_field_this_collider_name: self.this_collider_name = AuxTypes.String(self._io, self, self._root) if self.has_field_target_collider_name: self.target_collider_name = AuxTypes.String(self._io, self, self._root) @property def collider_check_on_init(self): if hasattr(self, '_m_collider_check_on_init'): return self._m_collider_check_on_init self._m_collider_check_on_init = self.base.collider_check_on_init return getattr(self, '_m_collider_check_on_init', None) @property def has_field_target_collider_name(self): if hasattr(self, '_m_has_field_target_collider_name'): return self._m_has_field_target_collider_name self._m_has_field_target_collider_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_collider_name', None) @property def has_field_collision_actions(self): if hasattr(self, '_m_has_field_collision_actions'): return self._m_has_field_collision_actions self._m_has_field_collision_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_collision_actions', None) @property def has_field_this_collider_name(self): if hasattr(self, '_m_has_field_this_collider_name'): return self._m_has_field_this_collider_name self._m_has_field_this_collider_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_this_collider_name', None) @property def collision(self): if hasattr(self, '_m_collision'): return self._m_collision self._m_collision = self.base.collision return getattr(self, '_m_collision', None) class BuoyantCombatExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id_list: self.level_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_level_id_list(self): if hasattr(self, '_m_has_field_level_id_list'): return self._m_has_field_level_id_list self._m_has_field_level_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_id_list', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigGuideProjectionGameStartCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_guide_type: self.guide_type = Output.EnumProjectionGameGuideType(self._io, self, self._root) if self.has_field_input_mode: self.input_mode = Output.EnumProjectionGameGuideInputMode(self._io, self, self._root) @property def has_field_guide_type(self): if hasattr(self, '_m_has_field_guide_type'): return self._m_has_field_guide_type self._m_has_field_guide_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_guide_type', None) @property def has_field_input_mode(self): if hasattr(self, '_m_has_field_input_mode'): return self._m_has_field_input_mode self._m_has_field_input_mode = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_input_mode', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class HandbookQuestGuideExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigActivityTalkScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talks: self.talks = Output.ArrayOfConfigTalkSchemeLengthU(self._io, self, self._root) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_activity_id', None) @property def has_field_talks(self): if hasattr(self, '_m_has_field_talks'): return self._m_has_field_talks self._m_has_field_talks = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_talks', None) class TriggerFlagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InteractionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityShopSheetCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumActivityShopSheetCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class MichiaePreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GenerateElemBall(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_drop_type: self.drop_type = Output.EnumDropElemBallType(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_ratio: self.ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_base_energy: self.base_energy = self._io.read_f4le() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_id', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_base_energy(self): if hasattr(self, '_m_has_field_base_energy'): return self._m_has_field_base_energy self._m_has_field_base_energy = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_base_energy', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ratio', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_drop_type(self): if hasattr(self, '_m_has_field_drop_type'): return self._m_has_field_drop_type self._m_has_field_drop_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_drop_type', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_born', None) class AddChargeValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_charge_type: self.charge_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_charge_type(self): if hasattr(self, '_m_has_field_charge_type'): return self._m_has_field_charge_type self._m_has_field_charge_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_charge_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfGrowCurveInfoLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.GrowCurveInfo(self._io, self, self._root)) class ByWetHitCollider(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MusicInfoConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_music_id: self.music_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_music_time: self.music_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id: self.level_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_music_name: self.music_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_music_desc: self.music_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_name: self.mark_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_desc: self.mark_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_instrument_id: self.instrument_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_instrument_id: self.avatar_instrument_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_instrument_id(self): if hasattr(self, '_m_has_field_instrument_id'): return self._m_has_field_instrument_id self._m_has_field_instrument_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_instrument_id', None) @property def has_field_music_name(self): if hasattr(self, '_m_has_field_music_name'): return self._m_has_field_music_name self._m_has_field_music_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_music_name', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_music_time(self): if hasattr(self, '_m_has_field_music_time'): return self._m_has_field_music_time self._m_has_field_music_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_music_time', None) @property def has_field_music_desc(self): if hasattr(self, '_m_has_field_music_desc'): return self._m_has_field_music_desc self._m_has_field_music_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_music_desc', None) @property def has_field_mark_name(self): if hasattr(self, '_m_has_field_mark_name'): return self._m_has_field_mark_name self._m_has_field_mark_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_mark_name', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_mark_desc(self): if hasattr(self, '_m_has_field_mark_desc'): return self._m_has_field_mark_desc self._m_has_field_mark_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_mark_desc', None) @property def has_field_music_id(self): if hasattr(self, '_m_has_field_music_id'): return self._m_has_field_music_id self._m_has_field_music_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_music_id', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_avatar_instrument_id(self): if hasattr(self, '_m_has_field_avatar_instrument_id'): return self._m_has_field_avatar_instrument_id self._m_has_field_avatar_instrument_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_avatar_instrument_id', None) class ChannellerSlabDungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pos', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) class DraftTextDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_draft_id: self.draft_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_btn_name: self.draft_btn_name = AuxTypes.String(self._io, self, self._root) if self.has_field_draft_btn_tips: self.draft_btn_tips = AuxTypes.String(self._io, self, self._root) if self.has_field_requirement_desc: self.requirement_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_limit_reason_desc: self.draft_limit_reason_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_warning_desc: self.limit_warning_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_desc: self.invite_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_guest_desc: self.invite_guest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_host_desc: self.invite_host_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite_warning_desc: self.invite_warning_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_title: self.draft_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_draft_limit_reason_desc(self): if hasattr(self, '_m_has_field_draft_limit_reason_desc'): return self._m_has_field_draft_limit_reason_desc self._m_has_field_draft_limit_reason_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_draft_limit_reason_desc', None) @property def has_field_requirement_desc(self): if hasattr(self, '_m_has_field_requirement_desc'): return self._m_has_field_requirement_desc self._m_has_field_requirement_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_requirement_desc', None) @property def has_field_draft_btn_name(self): if hasattr(self, '_m_has_field_draft_btn_name'): return self._m_has_field_draft_btn_name self._m_has_field_draft_btn_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_draft_btn_name', None) @property def has_field_invite_guest_desc(self): if hasattr(self, '_m_has_field_invite_guest_desc'): return self._m_has_field_invite_guest_desc self._m_has_field_invite_guest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_invite_guest_desc', None) @property def has_field_invite_warning_desc(self): if hasattr(self, '_m_has_field_invite_warning_desc'): return self._m_has_field_invite_warning_desc self._m_has_field_invite_warning_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_invite_warning_desc', None) @property def has_field_limit_warning_desc(self): if hasattr(self, '_m_has_field_limit_warning_desc'): return self._m_has_field_limit_warning_desc self._m_has_field_limit_warning_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_limit_warning_desc', None) @property def has_field_draft_title(self): if hasattr(self, '_m_has_field_draft_title'): return self._m_has_field_draft_title self._m_has_field_draft_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_draft_title', None) @property def has_field_draft_btn_tips(self): if hasattr(self, '_m_has_field_draft_btn_tips'): return self._m_has_field_draft_btn_tips self._m_has_field_draft_btn_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_draft_btn_tips', None) @property def has_field_draft_id(self): if hasattr(self, '_m_has_field_draft_id'): return self._m_has_field_draft_id self._m_has_field_draft_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_draft_id', None) @property def has_field_invite_desc(self): if hasattr(self, '_m_has_field_invite_desc'): return self._m_has_field_invite_desc self._m_has_field_invite_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_invite_desc', None) @property def has_field_invite_host_desc(self): if hasattr(self, '_m_has_field_invite_host_desc'): return self._m_has_field_invite_host_desc self._m_has_field_invite_host_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_invite_host_desc', None) class SeaLampSectionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GetPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TextMapPlatformTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicGameDrumConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delay_setting_range: self.delay_setting_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_drop_speed_setting_range: self.drop_speed_setting_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_key_sound_setting_range: self.key_sound_setting_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_perfect_range: self.perfect_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_great_range: self.great_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_long_press_end_compensation: self.long_press_end_compensation = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fail_time: self.fail_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_long_press_hit_interval: self.long_press_hit_interval = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_per_music_num: self.ugc_per_music_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_max_history_num: self.ugc_max_history_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_max_saved_score_num: self.ugc_max_saved_score_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_max_note_num: self.ugc_max_note_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_regional_note_limit: self.ugc_regional_note_limit = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_long_press_note_weight: self.ugc_long_press_note_weight = self._io.read_f4le() if self.has_field_ugc_rank_score_ratio_list: self.ugc_rank_score_ratio_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_publish_limit: self.ugc_publish_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_prefix_play_time: self.ugc_prefix_play_time = self._io.read_f4le() if self.has_field_ugc_suffix_play_time: self.ugc_suffix_play_time = self._io.read_f4le() if self.has_field_ugc_undo_buffer_size: self.ugc_undo_buffer_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_edit_viewport_range: self.ugc_edit_viewport_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_time_line_viewport_range: self.ugc_time_line_viewport_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_calib_music_info: self.calib_music_info = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_calib_viewport_range: self.calib_viewport_range = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_auto_attach_beat_count: self.ugc_auto_attach_beat_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ugc_tutorial_push_tip_ids: self.ugc_tutorial_push_tip_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_combo_effect_show_count: self.combo_effect_show_count = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ugc_editor_push_tip_ids: self.ugc_editor_push_tip_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ugc_cursor_move_params: self.ugc_cursor_move_params = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_music_play_speed_list: self.ugc_music_play_speed_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_ugc_tutorial_black_list: self.ugc_tutorial_black_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_ugc_max_history_num(self): if hasattr(self, '_m_has_field_ugc_max_history_num'): return self._m_has_field_ugc_max_history_num self._m_has_field_ugc_max_history_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_ugc_max_history_num', None) @property def has_field_long_press_end_compensation(self): if hasattr(self, '_m_has_field_long_press_end_compensation'): return self._m_has_field_long_press_end_compensation self._m_has_field_long_press_end_compensation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_long_press_end_compensation', None) @property def has_field_ugc_publish_limit(self): if hasattr(self, '_m_has_field_ugc_publish_limit'): return self._m_has_field_ugc_publish_limit self._m_has_field_ugc_publish_limit = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_ugc_publish_limit', None) @property def has_field_perfect_range(self): if hasattr(self, '_m_has_field_perfect_range'): return self._m_has_field_perfect_range self._m_has_field_perfect_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_perfect_range', None) @property def has_field_drop_speed_setting_range(self): if hasattr(self, '_m_has_field_drop_speed_setting_range'): return self._m_has_field_drop_speed_setting_range self._m_has_field_drop_speed_setting_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_drop_speed_setting_range', None) @property def has_field_key_sound_setting_range(self): if hasattr(self, '_m_has_field_key_sound_setting_range'): return self._m_has_field_key_sound_setting_range self._m_has_field_key_sound_setting_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_key_sound_setting_range', None) @property def has_field_ugc_tutorial_push_tip_ids(self): if hasattr(self, '_m_has_field_ugc_tutorial_push_tip_ids'): return self._m_has_field_ugc_tutorial_push_tip_ids self._m_has_field_ugc_tutorial_push_tip_ids = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_ugc_tutorial_push_tip_ids', None) @property def has_field_ugc_suffix_play_time(self): if hasattr(self, '_m_has_field_ugc_suffix_play_time'): return self._m_has_field_ugc_suffix_play_time self._m_has_field_ugc_suffix_play_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_ugc_suffix_play_time', None) @property def has_field_calib_music_info(self): if hasattr(self, '_m_has_field_calib_music_info'): return self._m_has_field_calib_music_info self._m_has_field_calib_music_info = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_calib_music_info', None) @property def has_field_ugc_editor_push_tip_ids(self): if hasattr(self, '_m_has_field_ugc_editor_push_tip_ids'): return self._m_has_field_ugc_editor_push_tip_ids self._m_has_field_ugc_editor_push_tip_ids = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_ugc_editor_push_tip_ids', None) @property def has_field_great_range(self): if hasattr(self, '_m_has_field_great_range'): return self._m_has_field_great_range self._m_has_field_great_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_great_range', None) @property def has_field_ugc_regional_note_limit(self): if hasattr(self, '_m_has_field_ugc_regional_note_limit'): return self._m_has_field_ugc_regional_note_limit self._m_has_field_ugc_regional_note_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_ugc_regional_note_limit', None) @property def has_field_ugc_auto_attach_beat_count(self): if hasattr(self, '_m_has_field_ugc_auto_attach_beat_count'): return self._m_has_field_ugc_auto_attach_beat_count self._m_has_field_ugc_auto_attach_beat_count = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_ugc_auto_attach_beat_count', None) @property def has_field_fail_time(self): if hasattr(self, '_m_has_field_fail_time'): return self._m_has_field_fail_time self._m_has_field_fail_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_fail_time', None) @property def has_field_ugc_rank_score_ratio_list(self): if hasattr(self, '_m_has_field_ugc_rank_score_ratio_list'): return self._m_has_field_ugc_rank_score_ratio_list self._m_has_field_ugc_rank_score_ratio_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_ugc_rank_score_ratio_list', None) @property def has_field_ugc_undo_buffer_size(self): if hasattr(self, '_m_has_field_ugc_undo_buffer_size'): return self._m_has_field_ugc_undo_buffer_size self._m_has_field_ugc_undo_buffer_size = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_ugc_undo_buffer_size', None) @property def has_field_ugc_edit_viewport_range(self): if hasattr(self, '_m_has_field_ugc_edit_viewport_range'): return self._m_has_field_ugc_edit_viewport_range self._m_has_field_ugc_edit_viewport_range = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_ugc_edit_viewport_range', None) @property def has_field_ugc_long_press_note_weight(self): if hasattr(self, '_m_has_field_ugc_long_press_note_weight'): return self._m_has_field_ugc_long_press_note_weight self._m_has_field_ugc_long_press_note_weight = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_ugc_long_press_note_weight', None) @property def has_field_ugc_per_music_num(self): if hasattr(self, '_m_has_field_ugc_per_music_num'): return self._m_has_field_ugc_per_music_num self._m_has_field_ugc_per_music_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_ugc_per_music_num', None) @property def has_field_ugc_prefix_play_time(self): if hasattr(self, '_m_has_field_ugc_prefix_play_time'): return self._m_has_field_ugc_prefix_play_time self._m_has_field_ugc_prefix_play_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_ugc_prefix_play_time', None) @property def has_field_ugc_music_play_speed_list(self): if hasattr(self, '_m_has_field_ugc_music_play_speed_list'): return self._m_has_field_ugc_music_play_speed_list self._m_has_field_ugc_music_play_speed_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_ugc_music_play_speed_list', None) @property def has_field_combo_effect_show_count(self): if hasattr(self, '_m_has_field_combo_effect_show_count'): return self._m_has_field_combo_effect_show_count self._m_has_field_combo_effect_show_count = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_combo_effect_show_count', None) @property def has_field_ugc_time_line_viewport_range(self): if hasattr(self, '_m_has_field_ugc_time_line_viewport_range'): return self._m_has_field_ugc_time_line_viewport_range self._m_has_field_ugc_time_line_viewport_range = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_ugc_time_line_viewport_range', None) @property def has_field_delay_setting_range(self): if hasattr(self, '_m_has_field_delay_setting_range'): return self._m_has_field_delay_setting_range self._m_has_field_delay_setting_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_delay_setting_range', None) @property def has_field_ugc_tutorial_black_list(self): if hasattr(self, '_m_has_field_ugc_tutorial_black_list'): return self._m_has_field_ugc_tutorial_black_list self._m_has_field_ugc_tutorial_black_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_ugc_tutorial_black_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_ugc_max_saved_score_num(self): if hasattr(self, '_m_has_field_ugc_max_saved_score_num'): return self._m_has_field_ugc_max_saved_score_num self._m_has_field_ugc_max_saved_score_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_ugc_max_saved_score_num', None) @property def has_field_calib_viewport_range(self): if hasattr(self, '_m_has_field_calib_viewport_range'): return self._m_has_field_calib_viewport_range self._m_has_field_calib_viewport_range = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_calib_viewport_range', None) @property def has_field_long_press_hit_interval(self): if hasattr(self, '_m_has_field_long_press_hit_interval'): return self._m_has_field_long_press_hit_interval self._m_has_field_long_press_hit_interval = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_long_press_hit_interval', None) @property def has_field_ugc_cursor_move_params(self): if hasattr(self, '_m_has_field_ugc_cursor_move_params'): return self._m_has_field_ugc_cursor_move_params self._m_has_field_ugc_cursor_move_params = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_ugc_cursor_move_params', None) @property def has_field_ugc_max_note_num(self): if hasattr(self, '_m_has_field_ugc_max_note_num'): return self._m_has_field_ugc_max_note_num self._m_has_field_ugc_max_note_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_ugc_max_note_num', None) class TowerFloorExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_floor_id: self.floor_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_floor_index: self.floor_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_group_id: self.level_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_override_monster_level: self.override_monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_team_num: self.team_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_five_stars: self.reward_id_five_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_ten_stars: self.reward_id_ten_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_fifteen_stars: self.reward_id_fifteen_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_three_stars: self.reward_id_three_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_six_stars: self.reward_id_six_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_nine_stars: self.reward_id_nine_stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_star_count: self.unlock_star_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_floor_level_config_id: self.floor_level_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bg_image: self.bg_image = AuxTypes.String(self._io, self, self._root) @property def has_field_bg_image(self): if hasattr(self, '_m_has_field_bg_image'): return self._m_has_field_bg_image self._m_has_field_bg_image = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_bg_image', None) @property def has_field_reward_id_three_stars(self): if hasattr(self, '_m_has_field_reward_id_three_stars'): return self._m_has_field_reward_id_three_stars self._m_has_field_reward_id_three_stars = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_id_three_stars', None) @property def has_field_reward_id_six_stars(self): if hasattr(self, '_m_has_field_reward_id_six_stars'): return self._m_has_field_reward_id_six_stars self._m_has_field_reward_id_six_stars = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reward_id_six_stars', None) @property def has_field_floor_level_config_id(self): if hasattr(self, '_m_has_field_floor_level_config_id'): return self._m_has_field_floor_level_config_id self._m_has_field_floor_level_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_floor_level_config_id', None) @property def has_field_reward_id_fifteen_stars(self): if hasattr(self, '_m_has_field_reward_id_fifteen_stars'): return self._m_has_field_reward_id_fifteen_stars self._m_has_field_reward_id_fifteen_stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_reward_id_fifteen_stars', None) @property def has_field_override_monster_level(self): if hasattr(self, '_m_has_field_override_monster_level'): return self._m_has_field_override_monster_level self._m_has_field_override_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_override_monster_level', None) @property def has_field_level_group_id(self): if hasattr(self, '_m_has_field_level_group_id'): return self._m_has_field_level_group_id self._m_has_field_level_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_group_id', None) @property def has_field_floor_index(self): if hasattr(self, '_m_has_field_floor_index'): return self._m_has_field_floor_index self._m_has_field_floor_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_floor_index', None) @property def has_field_unlock_star_count(self): if hasattr(self, '_m_has_field_unlock_star_count'): return self._m_has_field_unlock_star_count self._m_has_field_unlock_star_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_unlock_star_count', None) @property def has_field_team_num(self): if hasattr(self, '_m_has_field_team_num'): return self._m_has_field_team_num self._m_has_field_team_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_team_num', None) @property def has_field_reward_id_five_stars(self): if hasattr(self, '_m_has_field_reward_id_five_stars'): return self._m_has_field_reward_id_five_stars self._m_has_field_reward_id_five_stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id_five_stars', None) @property def has_field_floor_id(self): if hasattr(self, '_m_has_field_floor_id'): return self._m_has_field_floor_id self._m_has_field_floor_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_floor_id', None) @property def has_field_reward_id_nine_stars(self): if hasattr(self, '_m_has_field_reward_id_nine_stars'): return self._m_has_field_reward_id_nine_stars self._m_has_field_reward_id_nine_stars = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_reward_id_nine_stars', None) @property def has_field_reward_id_ten_stars(self): if hasattr(self, '_m_has_field_reward_id_ten_stars'): return self._m_has_field_reward_id_ten_stars self._m_has_field_reward_id_ten_stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_id_ten_stars', None) class QteStepActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BoredMonsterPoolConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioPlatformSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_audio_api_default_open_sl_es_requirements: self.audio_api_default_open_sl_es_requirements = Output.ArrayOfArrayOfAudioRequirementLengthULengthU(self._io, self, self._root) @property def has_field_audio_api_default_open_sl_es_requirements(self): if hasattr(self, '_m_has_field_audio_api_default_open_sl_es_requirements'): return self._m_has_field_audio_api_default_open_sl_es_requirements self._m_has_field_audio_api_default_open_sl_es_requirements = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_audio_api_default_open_sl_es_requirements', None) class EnumGuideMultiPlayerMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideMultiPlayerMode, self.data.value) return getattr(self, '_m_value', None) class GlobalSubShieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_main_shield_modifier_name: self.main_shield_modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_notify_mainshield_when_hit: self.notify_mainshield_when_hit = self._io.read_u1() @property def has_field_main_shield_modifier_name(self): if hasattr(self, '_m_has_field_main_shield_modifier_name'): return self._m_has_field_main_shield_modifier_name self._m_has_field_main_shield_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_shield_modifier_name', None) @property def has_field_notify_mainshield_when_hit(self): if hasattr(self, '_m_has_field_notify_mainshield_when_hit'): return self._m_has_field_notify_mainshield_when_hit self._m_has_field_notify_mainshield_when_hit = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_notify_mainshield_when_hit', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesVlqBase128LeSConfigAiCombatFixedMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiCombatFixedMoveData(self._io, self, self._root)) class TrialAvatarActivityDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_trial_avatar_index_id: self.trial_avatar_index_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_id: self.trial_avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_avatars_list: self.battle_avatars_list = AuxTypes.String(self._io, self, self._root) if self.has_field_first_pass_reward: self.first_pass_reward = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_brief_info: self.brief_info = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_trial_avatar_index_id(self): if hasattr(self, '_m_has_field_trial_avatar_index_id'): return self._m_has_field_trial_avatar_index_id self._m_has_field_trial_avatar_index_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_trial_avatar_index_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_battle_avatars_list(self): if hasattr(self, '_m_has_field_battle_avatars_list'): return self._m_has_field_battle_avatars_list self._m_has_field_battle_avatars_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_battle_avatars_list', None) @property def has_field_trial_avatar_id(self): if hasattr(self, '_m_has_field_trial_avatar_id'): return self._m_has_field_trial_avatar_id self._m_has_field_trial_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_trial_avatar_id', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_brief_info(self): if hasattr(self, '_m_has_field_brief_info'): return self._m_has_field_brief_info self._m_has_field_brief_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_brief_info', None) @property def has_field_first_pass_reward(self): if hasattr(self, '_m_has_field_first_pass_reward'): return self._m_has_field_first_pass_reward self._m_has_field_first_pass_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_first_pass_reward', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ConfigActionPanelState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_slot_map: self.slot_map = Output.DictOfEnumActionSlotTypeArrayOfConfigActionButtonLengthU(self._io, self, self._root) if self.has_field_slot_map_joypad_override: self.slot_map_joypad_override = Output.DictOfEnumActionSlotTypeArrayOfConfigActionButtonLengthU(self._io, self, self._root) @property def has_field_slot_map(self): if hasattr(self, '_m_has_field_slot_map'): return self._m_has_field_slot_map self._m_has_field_slot_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_slot_map', None) @property def has_field_slot_map_joypad_override(self): if hasattr(self, '_m_has_field_slot_map_joypad_override'): return self._m_has_field_slot_map_joypad_override self._m_has_field_slot_map_joypad_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_slot_map_joypad_override', None) class ChestShowCutsceneTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHuntingRefreshCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingRefreshCondType, self.data.value) return getattr(self, '_m_value', None) class EnumRelationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RelationType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigLocalGadgetCmdLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigLocalGadgetCmd(self._io, self, self._root)) class ConfigAiMixinSetControllerParameter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_on_success: self.on_success = Output.ConfigAiMixinActions(self._io, self, self._root) if self.has_field_on_fail: self.on_fail = Output.ConfigAiMixinActions(self._io, self, self._root) @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_types', None) @property def has_field_on_success(self): if hasattr(self, '_m_has_field_on_success'): return self._m_has_field_on_success self._m_has_field_on_success = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_success', None) @property def has_field_on_fail(self): if hasattr(self, '_m_has_field_on_fail'): return self._m_has_field_on_fail self._m_has_field_on_fail = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_fail', None) class SpawnAttach(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_attach_name: self.attach_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_attach_name(self): if hasattr(self, '_m_has_field_attach_name'): return self._m_has_field_attach_name self._m_has_field_attach_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_name', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiThreatSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_clear_threat_target_distance: self.clear_threat_target_distance = self._io.read_f4le() if self.has_field_clear_threat_edge_distance: self.clear_threat_edge_distance = self._io.read_f4le() if self.has_field_clear_threat_by_lost_path: self.clear_threat_by_lost_path = self._io.read_u1() if self.has_field_clear_threat_by_target_out_of_zone: self.clear_threat_by_target_out_of_zone = self._io.read_u1() if self.has_field_clear_threat_timer_by_distance: self.clear_threat_timer_by_distance = self._io.read_f4le() if self.has_field_clear_threat_timer_by_lost_path: self.clear_threat_timer_by_lost_path = self._io.read_f4le() if self.has_field_clear_threat_timer_by_target_out_of_zone: self.clear_threat_timer_by_target_out_of_zone = self._io.read_f4le() if self.has_field_view_threat_grow: self.view_threat_grow = self._io.read_f4le() if self.has_field_hear_threat_grow: self.hear_threat_grow = self._io.read_f4le() if self.has_field_feel_threat_grow: self.feel_threat_grow = self._io.read_f4le() if self.has_field_threat_decrease_speed: self.threat_decrease_speed = self._io.read_f4le() if self.has_field_threat_broadcast_range: self.threat_broadcast_range = self._io.read_f4le() if self.has_field_view_attenuation: self.view_attenuation = Output.ArrayOfAiPointLengthU(self._io, self, self._root) if self.has_field_hear_attenuation: self.hear_attenuation = Output.ArrayOfAiPointLengthU(self._io, self, self._root) if self.has_field_time_decrease_temper: self.time_decrease_temper = self._io.read_f4le() if self.has_field_resist_taunt_level: self.resist_taunt_level = Output.EnumTauntLevel(self._io, self, self._root) if self.has_field_aux_score_change_target_cd: self.aux_score_change_target_cd = self._io.read_f4le() if self.has_field_ability_global_value_score_system: self.ability_global_value_score_system = Output.ConfigAitsAbilityGlobalValueSetting(self._io, self, self._root) if self.has_field_target_distance_score_system: self.target_distance_score_system = Output.ConfigAitsTargetDistanceSetting(self._io, self, self._root) if self.has_field_target_bearing_score_system: self.target_bearing_score_system = Output.ConfigAitsTargetBearingSetting(self._io, self, self._root) @property def has_field_clear_threat_by_target_out_of_zone(self): if hasattr(self, '_m_has_field_clear_threat_by_target_out_of_zone'): return self._m_has_field_clear_threat_by_target_out_of_zone self._m_has_field_clear_threat_by_target_out_of_zone = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_clear_threat_by_target_out_of_zone', None) @property def has_field_time_decrease_temper(self): if hasattr(self, '_m_has_field_time_decrease_temper'): return self._m_has_field_time_decrease_temper self._m_has_field_time_decrease_temper = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_time_decrease_temper', None) @property def has_field_ability_global_value_score_system(self): if hasattr(self, '_m_has_field_ability_global_value_score_system'): return self._m_has_field_ability_global_value_score_system self._m_has_field_ability_global_value_score_system = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_ability_global_value_score_system', None) @property def has_field_view_threat_grow(self): if hasattr(self, '_m_has_field_view_threat_grow'): return self._m_has_field_view_threat_grow self._m_has_field_view_threat_grow = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_view_threat_grow', None) @property def has_field_clear_threat_timer_by_distance(self): if hasattr(self, '_m_has_field_clear_threat_timer_by_distance'): return self._m_has_field_clear_threat_timer_by_distance self._m_has_field_clear_threat_timer_by_distance = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_clear_threat_timer_by_distance', None) @property def has_field_threat_decrease_speed(self): if hasattr(self, '_m_has_field_threat_decrease_speed'): return self._m_has_field_threat_decrease_speed self._m_has_field_threat_decrease_speed = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_threat_decrease_speed', None) @property def has_field_resist_taunt_level(self): if hasattr(self, '_m_has_field_resist_taunt_level'): return self._m_has_field_resist_taunt_level self._m_has_field_resist_taunt_level = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_resist_taunt_level', None) @property def has_field_hear_threat_grow(self): if hasattr(self, '_m_has_field_hear_threat_grow'): return self._m_has_field_hear_threat_grow self._m_has_field_hear_threat_grow = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_hear_threat_grow', None) @property def has_field_clear_threat_edge_distance(self): if hasattr(self, '_m_has_field_clear_threat_edge_distance'): return self._m_has_field_clear_threat_edge_distance self._m_has_field_clear_threat_edge_distance = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_clear_threat_edge_distance', None) @property def has_field_feel_threat_grow(self): if hasattr(self, '_m_has_field_feel_threat_grow'): return self._m_has_field_feel_threat_grow self._m_has_field_feel_threat_grow = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_feel_threat_grow', None) @property def has_field_clear_threat_by_lost_path(self): if hasattr(self, '_m_has_field_clear_threat_by_lost_path'): return self._m_has_field_clear_threat_by_lost_path self._m_has_field_clear_threat_by_lost_path = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_clear_threat_by_lost_path', None) @property def has_field_clear_threat_target_distance(self): if hasattr(self, '_m_has_field_clear_threat_target_distance'): return self._m_has_field_clear_threat_target_distance self._m_has_field_clear_threat_target_distance = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_clear_threat_target_distance', None) @property def has_field_view_attenuation(self): if hasattr(self, '_m_has_field_view_attenuation'): return self._m_has_field_view_attenuation self._m_has_field_view_attenuation = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_view_attenuation', None) @property def has_field_hear_attenuation(self): if hasattr(self, '_m_has_field_hear_attenuation'): return self._m_has_field_hear_attenuation self._m_has_field_hear_attenuation = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_hear_attenuation', None) @property def has_field_target_distance_score_system(self): if hasattr(self, '_m_has_field_target_distance_score_system'): return self._m_has_field_target_distance_score_system self._m_has_field_target_distance_score_system = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_target_distance_score_system', None) @property def has_field_target_bearing_score_system(self): if hasattr(self, '_m_has_field_target_bearing_score_system'): return self._m_has_field_target_bearing_score_system self._m_has_field_target_bearing_score_system = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_target_bearing_score_system', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_clear_threat_timer_by_lost_path(self): if hasattr(self, '_m_has_field_clear_threat_timer_by_lost_path'): return self._m_has_field_clear_threat_timer_by_lost_path self._m_has_field_clear_threat_timer_by_lost_path = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_clear_threat_timer_by_lost_path', None) @property def has_field_aux_score_change_target_cd(self): if hasattr(self, '_m_has_field_aux_score_change_target_cd'): return self._m_has_field_aux_score_change_target_cd self._m_has_field_aux_score_change_target_cd = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_aux_score_change_target_cd', None) @property def has_field_threat_broadcast_range(self): if hasattr(self, '_m_has_field_threat_broadcast_range'): return self._m_has_field_threat_broadcast_range self._m_has_field_threat_broadcast_range = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_threat_broadcast_range', None) @property def has_field_clear_threat_timer_by_target_out_of_zone(self): if hasattr(self, '_m_has_field_clear_threat_timer_by_target_out_of_zone'): return self._m_has_field_clear_threat_timer_by_target_out_of_zone self._m_has_field_clear_threat_timer_by_target_out_of_zone = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_clear_threat_timer_by_target_out_of_zone', None) class ConfigAudioStateInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_group: self.state_group = AuxTypes.String(self._io, self, self._root) if self.has_field_state: self.state = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_state_group(self): if hasattr(self, '_m_has_field_state_group'): return self._m_has_field_state_group self._m_has_field_state_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_group', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class KvpOfDictAuxTypesStringDispConfigLcBaseIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigLcBaseIntee(self._io, self, self._root) class EnableAiStealthy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfBlossomRefreshCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BlossomRefreshCond(self._io, self, self._root)) class VelocityForceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mute_all: self.mute_all = self._io.read_u1() if self.has_field_use_all: self.use_all = self._io.read_u1() if self.has_field_include_forces: self.include_forces = Output.ArrayOfEnumVelocityForceTypeLengthU(self._io, self, self._root) if self.has_field_exclude_forces: self.exclude_forces = Output.ArrayOfEnumVelocityForceTypeLengthU(self._io, self, self._root) @property def has_field_exclude_forces(self): if hasattr(self, '_m_has_field_exclude_forces'): return self._m_has_field_exclude_forces self._m_has_field_exclude_forces = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_exclude_forces', None) @property def has_field_use_all(self): if hasattr(self, '_m_has_field_use_all'): return self._m_has_field_use_all self._m_has_field_use_all = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_all', None) @property def has_field_include_forces(self): if hasattr(self, '_m_has_field_include_forces'): return self._m_has_field_include_forces self._m_has_field_include_forces = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_include_forces', None) @property def has_field_mute_all(self): if hasattr(self, '_m_has_field_mute_all'): return self._m_has_field_mute_all self._m_has_field_mute_all = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mute_all', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigFishingZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPolygonZone(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_valid_radius: self.valid_radius = self._io.read_f4le() if self.has_field_flee_radius: self.flee_radius = self._io.read_f4le() if self.has_field_disable_in_multiplayer: self.disable_in_multiplayer = self._io.read_u1() if self.has_field_born_radius: self.born_radius = self._io.read_f4le() @property def has_field_flee_radius(self): if hasattr(self, '_m_has_field_flee_radius'): return self._m_has_field_flee_radius self._m_has_field_flee_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_flee_radius', None) @property def check_cd(self): if hasattr(self, '_m_check_cd'): return self._m_check_cd self._m_check_cd = self.base.check_cd return getattr(self, '_m_check_cd', None) @property def has_field_valid_radius(self): if hasattr(self, '_m_has_field_valid_radius'): return self._m_has_field_valid_radius self._m_has_field_valid_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_valid_radius', None) @property def has_field_disable_in_multiplayer(self): if hasattr(self, '_m_has_field_disable_in_multiplayer'): return self._m_has_field_disable_in_multiplayer self._m_has_field_disable_in_multiplayer = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_disable_in_multiplayer', None) @property def has_field_born_radius(self): if hasattr(self, '_m_has_field_born_radius'): return self._m_has_field_born_radius self._m_has_field_born_radius = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_born_radius', None) class QuestDialogDecoratorExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_decorator_content: self.decorator_content = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_decorator_content(self): if hasattr(self, '_m_has_field_decorator_content'): return self._m_has_field_decorator_content self._m_has_field_decorator_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_decorator_content', None) class ArrayOfSectrAttachStreamLayerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrAttachStreamLayer(self._io, self, self._root)) class ReliquaryAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_depot_id: self.depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_prop_value: self.prop_value = self._io.read_f4le() @property def has_field_prop_value(self): if hasattr(self, '_m_has_field_prop_value'): return self._m_has_field_prop_value self._m_has_field_prop_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_prop_value', None) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_prop_type', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_depot_id(self): if hasattr(self, '_m_has_field_depot_id'): return self._m_has_field_depot_id self._m_has_field_depot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_depot_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ArrayOfMusicEnemySettingsLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MusicEnemySettings(self._io, self, self._root)) class ConfigAnimator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_free_style_state_map: self.free_style_state_map = Output.DictOfAuxTypesVlqBase128LeSArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_state_anime_map: self.state_anime_map = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_logic_state_map: self.logic_state_map = Output.DictOfEnumAnimeGroupTypeConfigAnimGroup(self._io, self, self._root) @property def has_field_free_style_state_map(self): if hasattr(self, '_m_has_field_free_style_state_map'): return self._m_has_field_free_style_state_map self._m_has_field_free_style_state_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_free_style_state_map', None) @property def has_field_state_anime_map(self): if hasattr(self, '_m_has_field_state_anime_map'): return self._m_has_field_state_anime_map self._m_has_field_state_anime_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_anime_map', None) @property def has_field_logic_state_map(self): if hasattr(self, '_m_has_field_logic_state_map'): return self._m_has_field_logic_state_map self._m_has_field_logic_state_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic_state_map', None) class ActivityIslandPartyStageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerWitchTimeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ignore_target_type: self.ignore_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_timescale: self.timescale = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_use_max: self.use_max = self._io.read_u1() if self.has_field_enable_effect: self.enable_effect = self._io.read_u1() if self.has_field_enable_delay: self.enable_delay = self._io.read_u1() if self.has_field_delay_time_scale: self.delay_time_scale = self._io.read_f4le() if self.has_field_delay_duration: self.delay_duration = self._io.read_f4le() if self.has_field_open_effect_pattern: self.open_effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_close_effect_pattern: self.close_effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_weather_pattern: self.weather_pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_use_max(self): if hasattr(self, '_m_has_field_use_max'): return self._m_has_field_use_max self._m_has_field_use_max = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_use_max', None) @property def has_field_delay_time_scale(self): if hasattr(self, '_m_has_field_delay_time_scale'): return self._m_has_field_delay_time_scale self._m_has_field_delay_time_scale = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_delay_time_scale', None) @property def has_field_weather_pattern(self): if hasattr(self, '_m_has_field_weather_pattern'): return self._m_has_field_weather_pattern self._m_has_field_weather_pattern = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_weather_pattern', None) @property def has_field_ignore_target_type(self): if hasattr(self, '_m_has_field_ignore_target_type'): return self._m_has_field_ignore_target_type self._m_has_field_ignore_target_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_ignore_target_type', None) @property def has_field_close_effect_pattern(self): if hasattr(self, '_m_has_field_close_effect_pattern'): return self._m_has_field_close_effect_pattern self._m_has_field_close_effect_pattern = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_close_effect_pattern', None) @property def has_field_enable_effect(self): if hasattr(self, '_m_has_field_enable_effect'): return self._m_has_field_enable_effect self._m_has_field_enable_effect = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_enable_effect', None) @property def has_field_timescale(self): if hasattr(self, '_m_has_field_timescale'): return self._m_has_field_timescale self._m_has_field_timescale = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_timescale', None) @property def has_field_enable_delay(self): if hasattr(self, '_m_has_field_enable_delay'): return self._m_has_field_enable_delay self._m_has_field_enable_delay = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_enable_delay', None) @property def has_field_open_effect_pattern(self): if hasattr(self, '_m_has_field_open_effect_pattern'): return self._m_has_field_open_effect_pattern self._m_has_field_open_effect_pattern = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_open_effect_pattern', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_delay_duration(self): if hasattr(self, '_m_has_field_delay_duration'): return self._m_has_field_delay_duration self._m_has_field_delay_duration = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_delay_duration', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WatcherPredicateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumVodPlayerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VodPlayerType, self.data.value) return getattr(self, '_m_value', None) class ConfigLevelPolygonTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicUInt32noLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiReturnToBornPosData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiReturnToBornPosData(self._io, self, self._root) class EnumRetreatType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RetreatType, self.data.value) return getattr(self, '_m_value', None) class DvalinS01boxMoxeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HuntingGroupInfoExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_id: self.region_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_type: self.point_type = Output.EnumHuntingCluePointType(self._io, self, self._root) if self.has_field_ref_index: self.ref_index = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pos_type: self.pos_type = Output.EnumHuntingMonsterCreatePosType(self._io, self, self._root) @property def has_field_region_id(self): if hasattr(self, '_m_has_field_region_id'): return self._m_has_field_region_id self._m_has_field_region_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_region_id', None) @property def has_field_ref_index(self): if hasattr(self, '_m_has_field_ref_index'): return self._m_has_field_ref_index self._m_has_field_ref_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ref_index', None) @property def has_field_pos_type(self): if hasattr(self, '_m_has_field_pos_type'): return self._m_has_field_pos_type self._m_has_field_pos_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pos_type', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_point_type', None) class EnumChessCardTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardTargetType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigMusicFixedTimeTransitionsLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMusicFixedTimeTransitions(self._io, self, self._root)) class ConfigHomeFishpondSet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_fishpond_map: self.fishpond_map = Output.DictOfAuxTypesVlqBase128LeUConfigHomeFishpond(self._io, self, self._root) @property def has_field_fishpond_map(self): if hasattr(self, '_m_has_field_fishpond_map'): return self._m_has_field_fishpond_map self._m_has_field_fishpond_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_fishpond_map', None) class EnumAttackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AttackType, self.data.value) return getattr(self, '_m_value', None) class ConfigMultiBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ConfigMusicTimeTransitions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_interval: self.interval = self._io.read_f4le() if self.has_field_repetitives: self.repetitives = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_fixed_times: self.fixed_times = Output.ArrayOfConfigMusicFixedTimeTransitionsLengthU(self._io, self, self._root) @property def has_field_interval(self): if hasattr(self, '_m_has_field_interval'): return self._m_has_field_interval self._m_has_field_interval = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_interval', None) @property def has_field_repetitives(self): if hasattr(self, '_m_has_field_repetitives'): return self._m_has_field_repetitives self._m_has_field_repetitives = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_repetitives', None) @property def has_field_fixed_times(self): if hasattr(self, '_m_has_field_fixed_times'): return self._m_has_field_fixed_times self._m_has_field_fixed_times = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fixed_times', None) class DragonSpineStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SummerTimeV2overallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_reward_id: self.dungeon_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_dungeon_reward_id(self): if hasattr(self, '_m_has_field_dungeon_reward_id'): return self._m_has_field_dungeon_reward_id self._m_has_field_dungeon_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_reward_id', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_id', None) class EnumFleurFairDungeonStatType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FleurFairDungeonStatType, self.data.value) return getattr(self, '_m_value', None) class LoadingAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DragonSpinePreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_level: self.unlock_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_duration: self.content_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id_list: self.quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_content_duration(self): if hasattr(self, '_m_has_field_content_duration'): return self._m_has_field_content_duration self._m_has_field_content_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_content_duration', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_unlock_level(self): if hasattr(self, '_m_has_field_unlock_level'): return self._m_has_field_unlock_level self._m_has_field_unlock_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_level', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_quest_id_list(self): if hasattr(self, '_m_has_field_quest_id_list'): return self._m_has_field_quest_id_list self._m_has_field_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_quest_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class EShaderDataComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfNumberItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberItemOptionArrayInfo(self._io, self, self._root)) class ChannellerSlabLoopDungeonConditionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_type: self.condition_type = Output.EnumChannellerSlabCondition(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_condition_param1: self.condition_param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_param2: self.condition_param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exclusive_id: self.exclusive_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_exclusive_id(self): if hasattr(self, '_m_has_field_exclusive_id'): return self._m_has_field_exclusive_id self._m_has_field_exclusive_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_exclusive_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_condition_type(self): if hasattr(self, '_m_has_field_condition_type'): return self._m_has_field_condition_type self._m_has_field_condition_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_condition_type', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_condition_param2(self): if hasattr(self, '_m_has_field_condition_param2'): return self._m_has_field_condition_param2 self._m_has_field_condition_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_condition_param2', None) @property def has_field_condition_param1(self): if hasattr(self, '_m_has_field_condition_param1'): return self._m_has_field_condition_param1 self._m_has_field_condition_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_condition_param1', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ActivityIslandPartyStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_type: self.stage_type = Output.EnumActivityIslandPartyStageType(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series_id: self.series_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_id: self.match_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_draft_id: self.draft_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_banner_desc: self.banner_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fail_hint: self.fail_hint = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_score_id_list: self.score_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_fail_hint(self): if hasattr(self, '_m_has_field_fail_hint'): return self._m_has_field_fail_hint self._m_has_field_fail_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_fail_hint', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_stage_type(self): if hasattr(self, '_m_has_field_stage_type'): return self._m_has_field_stage_type self._m_has_field_stage_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_type', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_match_id(self): if hasattr(self, '_m_has_field_match_id'): return self._m_has_field_match_id self._m_has_field_match_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_match_id', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_draft_id(self): if hasattr(self, '_m_has_field_draft_id'): return self._m_has_field_draft_id self._m_has_field_draft_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_draft_id', None) @property def has_field_score_id_list(self): if hasattr(self, '_m_has_field_score_id_list'): return self._m_has_field_score_id_list self._m_has_field_score_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_score_id_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_banner_desc(self): if hasattr(self, '_m_has_field_banner_desc'): return self._m_has_field_banner_desc self._m_has_field_banner_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_banner_desc', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_series_id(self): if hasattr(self, '_m_has_field_series_id'): return self._m_has_field_series_id self._m_has_field_series_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_series_id', None) class FixedAvatarRushMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_time_range: self.time_range = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_range: self.max_range = self._io.read_f4le() if self.has_field_animator_state_i_ds: self.animator_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_override_move_collider: self.override_move_collider = AuxTypes.String(self._io, self, self._root) if self.has_field_is_in_air: self.is_in_air = self._io.read_u1() if self.has_field_check_animator_state_on_exit_only: self.check_animator_state_on_exit_only = self._io.read_u1() if self.has_field_ignore_detect_forward: self.ignore_detect_forward = self._io.read_u1() if self.has_field_exact_arrive: self.exact_arrive = self._io.read_u1() @property def has_field_time_range(self): if hasattr(self, '_m_has_field_time_range'): return self._m_has_field_time_range self._m_has_field_time_range = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_time_range', None) @property def has_field_ignore_detect_forward(self): if hasattr(self, '_m_has_field_ignore_detect_forward'): return self._m_has_field_ignore_detect_forward self._m_has_field_ignore_detect_forward = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_ignore_detect_forward', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_max_range(self): if hasattr(self, '_m_has_field_max_range'): return self._m_has_field_max_range self._m_has_field_max_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_max_range', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_exact_arrive(self): if hasattr(self, '_m_has_field_exact_arrive'): return self._m_has_field_exact_arrive self._m_has_field_exact_arrive = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_exact_arrive', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_is_in_air(self): if hasattr(self, '_m_has_field_is_in_air'): return self._m_has_field_is_in_air self._m_has_field_is_in_air = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_is_in_air', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_animator_state_i_ds(self): if hasattr(self, '_m_has_field_animator_state_i_ds'): return self._m_has_field_animator_state_i_ds self._m_has_field_animator_state_i_ds = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_animator_state_i_ds', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_move_collider(self): if hasattr(self, '_m_has_field_override_move_collider'): return self._m_has_field_override_move_collider self._m_has_field_override_move_collider = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_override_move_collider', None) @property def has_field_check_animator_state_on_exit_only(self): if hasattr(self, '_m_has_field_check_animator_state_on_exit_only'): return self._m_has_field_check_animator_state_on_exit_only self._m_has_field_check_animator_state_on_exit_only = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_check_animator_state_on_exit_only', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_to_pos', None) class MoveToTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRocketJumpType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RocketJumpType, self.data.value) return getattr(self, '_m_value', None) class ConfigRegionalPlayLightStone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigRegionalPlayBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_energy_sgv: self.energy_sgv = AuxTypes.String(self._io, self, self._root) if self.has_field_level_sgv: self.level_sgv = AuxTypes.String(self._io, self, self._root) @property def is_team(self): if hasattr(self, '_m_is_team'): return self._m_is_team self._m_is_team = self.base.is_team return getattr(self, '_m_is_team', None) @property def var_list(self): if hasattr(self, '_m_var_list'): return self._m_var_list self._m_var_list = self.base.var_list return getattr(self, '_m_var_list', None) @property def bind_scene(self): if hasattr(self, '_m_bind_scene'): return self._m_bind_scene self._m_bind_scene = self.base.bind_scene return getattr(self, '_m_bind_scene', None) @property def ability_group_name_list(self): if hasattr(self, '_m_ability_group_name_list'): return self._m_ability_group_name_list self._m_ability_group_name_list = self.base.ability_group_name_list return getattr(self, '_m_ability_group_name_list', None) @property def has_field_energy_sgv(self): if hasattr(self, '_m_has_field_energy_sgv'): return self._m_has_field_energy_sgv self._m_has_field_energy_sgv = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_energy_sgv', None) @property def play_type(self): if hasattr(self, '_m_play_type'): return self._m_play_type self._m_play_type = self.base.play_type return getattr(self, '_m_play_type', None) @property def has_field_level_sgv(self): if hasattr(self, '_m_has_field_level_sgv'): return self._m_has_field_level_sgv self._m_has_field_level_sgv = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_level_sgv', None) class PerfRatingCategoryComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopmallSubTabExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_tag_name: self.sub_tag_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sub_tag_name(self): if hasattr(self, '_m_has_field_sub_tag_name'): return self._m_has_field_sub_tag_name self._m_has_field_sub_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_tag_name', None) class QuestResCollectionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfSectrStreamLayerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrStreamLayer(self._io, self, self._root)) class ConcernTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DungeonPassExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEntityColliderType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityColliderType, self.data.value) return getattr(self, '_m_value', None) class ConfigDitherByBetweenCameraAndAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_detect_dither_range: self.detect_dither_range = self._io.read_f4le() @property def has_field_detect_dither_range(self): if hasattr(self, '_m_has_field_detect_dither_range'): return self._m_has_field_detect_dither_range self._m_has_field_detect_dither_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_detect_dither_range', None) class ConfigGadgetUiItemGroupShowCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_show_cond_type: self.show_cond_type = Output.EnumGadgetUiItemGroupShowCondType(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_show_cond_type(self): if hasattr(self, '_m_has_field_show_cond_type'): return self._m_has_field_show_cond_type self._m_has_field_show_cond_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show_cond_type', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_priority', None) class EnumInputValueType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InputValueType, self.data.value) return getattr(self, '_m_value', None) class ConfigSchedulerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigGadgetConsoleOperationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigGadgetConsoleOperationType, self.data.value) return getattr(self, '_m_value', None) class EnumShopType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopType, self.data.value) return getattr(self, '_m_value', None) class BornRandomInShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.BornRandom(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shape_name: self.shape_name = AuxTypes.String(self._io, self, self._root) @property def has_field_shape_name(self): if hasattr(self, '_m_has_field_shape_name'): return self._m_has_field_shape_name self._m_has_field_shape_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shape_name', None) class EnumHitBoxType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HitBoxType, self.data.value) return getattr(self, '_m_value', None) class PlayerLevelLockExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_world_level: self.world_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_main_quest_id: self.unlock_main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_player_level: self.unlock_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_level_upper_limit: self.player_level_upper_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_desc: self.unlock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_unlock_main_quest_id(self): if hasattr(self, '_m_has_field_unlock_main_quest_id'): return self._m_has_field_unlock_main_quest_id self._m_has_field_unlock_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_main_quest_id', None) @property def has_field_player_level_upper_limit(self): if hasattr(self, '_m_has_field_player_level_upper_limit'): return self._m_has_field_player_level_upper_limit self._m_has_field_player_level_upper_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_player_level_upper_limit', None) @property def has_field_unlock_player_level(self): if hasattr(self, '_m_has_field_unlock_player_level'): return self._m_has_field_unlock_player_level self._m_has_field_unlock_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_player_level', None) @property def has_field_unlock_desc(self): if hasattr(self, '_m_has_field_unlock_desc'): return self._m_has_field_unlock_desc self._m_has_field_unlock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_desc', None) @property def has_field_world_level(self): if hasattr(self, '_m_has_field_world_level'): return self._m_has_field_world_level self._m_has_field_world_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_world_level', None) class DictOfAuxTypesStringAudioWeatherProperties(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAudioWeatherProperties(self._io, self, self._root)) class ConfigCrowdSpawnInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_crowd_type_id: self.crowd_type_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_anim_config_id: self.anim_config_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_spawn_position: self.spawn_position = Output.Vector(self._io, self, self._root) if self.has_field_spawn_face_fwd: self.spawn_face_fwd = Output.Vector(self._io, self, self._root) if self.has_field_has_collider: self.has_collider = self._io.read_u1() if self.has_field_sit_on_chair: self.sit_on_chair = self._io.read_u1() if self.has_field_hair_color: self.hair_color = Output.ColorVector(self._io, self, self._root) if self.has_field_body_colors: self.body_colors = Output.ArrayOfColorVectorLengthU(self._io, self, self._root) if self.has_field_instance_id: self.instance_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_hair_color(self): if hasattr(self, '_m_has_field_hair_color'): return self._m_has_field_hair_color self._m_has_field_hair_color = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_hair_color', None) @property def has_field_has_collider(self): if hasattr(self, '_m_has_field_has_collider'): return self._m_has_field_has_collider self._m_has_field_has_collider = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_has_collider', None) @property def has_field_instance_id(self): if hasattr(self, '_m_has_field_instance_id'): return self._m_has_field_instance_id self._m_has_field_instance_id = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_instance_id', None) @property def has_field_sit_on_chair(self): if hasattr(self, '_m_has_field_sit_on_chair'): return self._m_has_field_sit_on_chair self._m_has_field_sit_on_chair = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_sit_on_chair', None) @property def has_field_crowd_type_id(self): if hasattr(self, '_m_has_field_crowd_type_id'): return self._m_has_field_crowd_type_id self._m_has_field_crowd_type_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_crowd_type_id', None) @property def has_field_anim_config_id(self): if hasattr(self, '_m_has_field_anim_config_id'): return self._m_has_field_anim_config_id self._m_has_field_anim_config_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_anim_config_id', None) @property def has_field_spawn_position(self): if hasattr(self, '_m_has_field_spawn_position'): return self._m_has_field_spawn_position self._m_has_field_spawn_position = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_spawn_position', None) @property def has_field_body_colors(self): if hasattr(self, '_m_has_field_body_colors'): return self._m_has_field_body_colors self._m_has_field_body_colors = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_body_colors', None) @property def has_field_spawn_face_fwd(self): if hasattr(self, '_m_has_field_spawn_face_fwd'): return self._m_has_field_spawn_face_fwd self._m_has_field_spawn_face_fwd = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_spawn_face_fwd', None) class GuideCameraActionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RejectAttackMixinV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_limit_time: self.limit_time = self._io.read_f4le() if self.has_field_type: self.type = Output.EnumRejectEventType(self._io, self, self._root) if self.has_field_is_white_list: self.is_white_list = self._io.read_u1() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_limit_time(self): if hasattr(self, '_m_has_field_limit_time'): return self._m_has_field_limit_time self._m_has_field_limit_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_limit_time', None) @property def has_field_is_white_list(self): if hasattr(self, '_m_has_field_is_white_list'): return self._m_has_field_is_white_list self._m_has_field_is_white_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_white_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tags', None) class EnumJobType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.JobType, self.data.value) return getattr(self, '_m_value', None) class ContextActionSelectMainQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_quest_id', None) class MonsterCategoryComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMoveToDirectionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoveToDirectionType, self.data.value) return getattr(self, '_m_value', None) class ConfigActionPanelMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_state_map: self.state_map = Output.DictOfEnumActionPanelStateAuxTypesString(self._io, self, self._root) @property def has_field_state_map(self): if hasattr(self, '_m_has_field_state_map'): return self._m_has_field_state_map self._m_has_field_state_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_map', None) class MovePlatformDelayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeErosionAreaExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_a1: self.a1 = self._io.read_f4le() if self.has_field_a2: self.a2 = self._io.read_f4le() if self.has_field_a3: self.a3 = self._io.read_f4le() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_a1(self): if hasattr(self, '_m_has_field_a1'): return self._m_has_field_a1 self._m_has_field_a1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_a1', None) @property def has_field_a2(self): if hasattr(self, '_m_has_field_a2'): return self._m_has_field_a2 self._m_has_field_a2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_a2', None) @property def has_field_a3(self): if hasattr(self, '_m_has_field_a3'): return self._m_has_field_a3 self._m_has_field_a3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_a3', None) class TreasureMapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward_id: self.preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_pos: self.npc_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_treasure_days: self.treasure_days = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_probability: self.monster_probability = self._io.read_f4le() if self.has_field_reward_worktop_gadget_id: self.reward_worktop_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_token_material_id: self.token_material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unit_token_drop_id: self.unit_token_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_reward_id: self.mp_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_host_reward_limit: self.host_reward_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guest_reward_limit: self.guest_reward_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_challenge_index: self.mp_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_challenge_index: self.bonus_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_gadget_suite: self.challenge_gadget_suite = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spot_revise_level_id: self.spot_revise_level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detector_material_id: self.detector_material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_child_quest_id: self.guide_child_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_front_child_quest_id: self.front_child_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_spot_revise_level_id(self): if hasattr(self, '_m_has_field_spot_revise_level_id'): return self._m_has_field_spot_revise_level_id self._m_has_field_spot_revise_level_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_spot_revise_level_id', None) @property def has_field_unit_token_drop_id(self): if hasattr(self, '_m_has_field_unit_token_drop_id'): return self._m_has_field_unit_token_drop_id self._m_has_field_unit_token_drop_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_unit_token_drop_id', None) @property def has_field_front_child_quest_id(self): if hasattr(self, '_m_has_field_front_child_quest_id'): return self._m_has_field_front_child_quest_id self._m_has_field_front_child_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_front_child_quest_id', None) @property def has_field_treasure_days(self): if hasattr(self, '_m_has_field_treasure_days'): return self._m_has_field_treasure_days self._m_has_field_treasure_days = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_treasure_days', None) @property def has_field_bonus_challenge_index(self): if hasattr(self, '_m_has_field_bonus_challenge_index'): return self._m_has_field_bonus_challenge_index self._m_has_field_bonus_challenge_index = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_bonus_challenge_index', None) @property def has_field_npc_pos(self): if hasattr(self, '_m_has_field_npc_pos'): return self._m_has_field_npc_pos self._m_has_field_npc_pos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_npc_pos', None) @property def has_field_detector_material_id(self): if hasattr(self, '_m_has_field_detector_material_id'): return self._m_has_field_detector_material_id self._m_has_field_detector_material_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_detector_material_id', None) @property def has_field_mp_reward_id(self): if hasattr(self, '_m_has_field_mp_reward_id'): return self._m_has_field_mp_reward_id self._m_has_field_mp_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_mp_reward_id', None) @property def has_field_token_material_id(self): if hasattr(self, '_m_has_field_token_material_id'): return self._m_has_field_token_material_id self._m_has_field_token_material_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_token_material_id', None) @property def has_field_reward_worktop_gadget_id(self): if hasattr(self, '_m_has_field_reward_worktop_gadget_id'): return self._m_has_field_reward_worktop_gadget_id self._m_has_field_reward_worktop_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_worktop_gadget_id', None) @property def has_field_mp_challenge_index(self): if hasattr(self, '_m_has_field_mp_challenge_index'): return self._m_has_field_mp_challenge_index self._m_has_field_mp_challenge_index = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_mp_challenge_index', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_guide_child_quest_id(self): if hasattr(self, '_m_has_field_guide_child_quest_id'): return self._m_has_field_guide_child_quest_id self._m_has_field_guide_child_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_guide_child_quest_id', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_monster_probability(self): if hasattr(self, '_m_has_field_monster_probability'): return self._m_has_field_monster_probability self._m_has_field_monster_probability = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_monster_probability', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_challenge_gadget_suite(self): if hasattr(self, '_m_has_field_challenge_gadget_suite'): return self._m_has_field_challenge_gadget_suite self._m_has_field_challenge_gadget_suite = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_challenge_gadget_suite', None) @property def has_field_host_reward_limit(self): if hasattr(self, '_m_has_field_host_reward_limit'): return self._m_has_field_host_reward_limit self._m_has_field_host_reward_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_host_reward_limit', None) @property def has_field_guest_reward_limit(self): if hasattr(self, '_m_has_field_guest_reward_limit'): return self._m_has_field_guest_reward_limit self._m_has_field_guest_reward_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_guest_reward_limit', None) @property def has_field_preview_reward_id(self): if hasattr(self, '_m_has_field_preview_reward_id'): return self._m_has_field_preview_reward_id self._m_has_field_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_preview_reward_id', None) class ConfigGuideLevelTypeCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumGuideLevelType(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class CollectorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAbilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_unique: self.is_unique = self._io.read_u1() @property def has_field_is_unique(self): if hasattr(self, '_m_has_field_is_unique'): return self._m_has_field_is_unique self._m_has_field_is_unique = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_unique', None) class EnumPerfCostRatioGrade(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfCostRatioGrade, self.data.value) return getattr(self, '_m_value', None) class BattlePassRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_index_id: self.index_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_reward_id_list: self.free_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_paid_reward_id_list: self.paid_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_up: self.show_up = self._io.read_u1() @property def has_field_show_up(self): if hasattr(self, '_m_has_field_show_up'): return self._m_has_field_show_up self._m_has_field_show_up = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_show_up', None) @property def has_field_free_reward_id_list(self): if hasattr(self, '_m_has_field_free_reward_id_list'): return self._m_has_field_free_reward_id_list self._m_has_field_free_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_free_reward_id_list', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_paid_reward_id_list(self): if hasattr(self, '_m_has_field_paid_reward_id_list'): return self._m_has_field_paid_reward_id_list self._m_has_field_paid_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_paid_reward_id_list', None) @property def has_field_index_id(self): if hasattr(self, '_m_has_field_index_id'): return self._m_has_field_index_id self._m_has_field_index_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_index_id', None) class LimitRegionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoutineActionContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRoutineActionype(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class ActivitySpiceStageDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTowerBuffLastingType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TowerBuffLastingType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigElemBallLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigElemBall(self._io, self, self._root)) class MechanicusCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_points: self.cost_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_type: self.card_type = Output.EnumMechanicusCardType(self._io, self, self._root) if self.has_field_effect_id: self.effect_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_last_round: self.last_round = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param_list: self.desc_param_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_gear_id: self.gear_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cost_points(self): if hasattr(self, '_m_has_field_cost_points'): return self._m_has_field_cost_points self._m_has_field_cost_points = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cost_points', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_desc_param_list(self): if hasattr(self, '_m_has_field_desc_param_list'): return self._m_has_field_desc_param_list self._m_has_field_desc_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc_param_list', None) @property def has_field_effect_id(self): if hasattr(self, '_m_has_field_effect_id'): return self._m_has_field_effect_id self._m_has_field_effect_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effect_id', None) @property def has_field_last_round(self): if hasattr(self, '_m_has_field_last_round'): return self._m_has_field_last_round self._m_has_field_last_round = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_last_round', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_card_type(self): if hasattr(self, '_m_has_field_card_type'): return self._m_has_field_card_type self._m_has_field_card_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_card_type', None) @property def has_field_gear_id(self): if hasattr(self, '_m_has_field_gear_id'): return self._m_has_field_gear_id self._m_has_field_gear_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_gear_id', None) class RewardTransformConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByTargetWeatherName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weather_name: self.weather_name = AuxTypes.String(self._io, self, self._root) @property def has_field_weather_name(self): if hasattr(self, '_m_has_field_weather_name'): return self._m_has_field_weather_name self._m_has_field_weather_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weather_name', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ServerCreateGadgetOnKillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id_list: self.gadget_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_random_create: self.random_create = self._io.read_u1() if self.has_field_use_origin_owner_as_gadget_owner: self.use_origin_owner_as_gadget_owner = self._io.read_u1() if self.has_field_life_by_owner_is_alive: self.life_by_owner_is_alive = self._io.read_u1() @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camp_id', None) @property def has_field_random_create(self): if hasattr(self, '_m_has_field_random_create'): return self._m_has_field_random_create self._m_has_field_random_create = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_create', None) @property def has_field_use_origin_owner_as_gadget_owner(self): if hasattr(self, '_m_has_field_use_origin_owner_as_gadget_owner'): return self._m_has_field_use_origin_owner_as_gadget_owner self._m_has_field_use_origin_owner_as_gadget_owner = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_origin_owner_as_gadget_owner', None) @property def has_field_life_by_owner_is_alive(self): if hasattr(self, '_m_has_field_life_by_owner_is_alive'): return self._m_has_field_life_by_owner_is_alive self._m_has_field_life_by_owner_is_alive = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_life_by_owner_is_alive', None) @property def has_field_gadget_id_list(self): if hasattr(self, '_m_has_field_gadget_id_list'): return self._m_has_field_gadget_id_list self._m_has_field_gadget_id_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id_list', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAttackCircle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSimpleAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_fan_angle: self.fan_angle = self._io.read_f4le() if self.has_field_radius: self.radius = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_inner_radius: self.inner_radius = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_detect_direction: self.detect_direction = Output.EnumCircleDetectDirection(self._io, self, self._root) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_height', None) @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def use_custom_shape(self): if hasattr(self, '_m_use_custom_shape'): return self._m_use_custom_shape self._m_use_custom_shape = self.base.use_custom_shape return getattr(self, '_m_use_custom_shape', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def has_field_detect_direction(self): if hasattr(self, '_m_has_field_detect_direction'): return self._m_has_field_detect_direction self._m_has_field_detect_direction = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_detect_direction', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_radius', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def has_field_inner_radius(self): if hasattr(self, '_m_has_field_inner_radius'): return self._m_has_field_inner_radius self._m_has_field_inner_radius = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_inner_radius', None) @property def has_field_fan_angle(self): if hasattr(self, '_m_has_field_fan_angle'): return self._m_has_field_fan_angle self._m_has_field_fan_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fan_angle', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class CreaterDirComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGroupLinksExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigGadgetPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigGadgetPattern(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetCollidedPattern(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigMultiBulletPattern(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBulletPattern(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigInterFade(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_start_fade_in_duration: self.start_fade_in_duration = self._io.read_f4le() if self.has_field_start_fade_out_duration: self.start_fade_out_duration = self._io.read_f4le() @property def has_field_start_fade_in_duration(self): if hasattr(self, '_m_has_field_start_fade_in_duration'): return self._m_has_field_start_fade_in_duration self._m_has_field_start_fade_in_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start_fade_in_duration', None) @property def has_field_start_fade_out_duration(self): if hasattr(self, '_m_has_field_start_fade_out_duration'): return self._m_has_field_start_fade_out_duration self._m_has_field_start_fade_out_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_fade_out_duration', None) class QteStepExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestPlaceConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_place_id: self.place_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_place_id(self): if hasattr(self, '_m_has_field_place_id'): return self._m_has_field_place_id self._m_has_field_place_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_place_id', None) class MoonfinTrialExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingBitesBaitData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFishingBitesBaitData(self._io, self, self._root) class ConfigAiPickActionPointCriteria(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_point_type: self.point_type = Output.EnumActionPointType(self._io, self, self._root) if self.has_field_detect_distance: self.detect_distance = self._io.read_f4le() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_pose: self.pose = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_nerve_trigger: self.nerve_trigger = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_nerve_trigger(self): if hasattr(self, '_m_has_field_nerve_trigger'): return self._m_has_field_nerve_trigger self._m_has_field_nerve_trigger = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_nerve_trigger', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_type', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_detect_distance(self): if hasattr(self, '_m_has_field_detect_distance'): return self._m_has_field_detect_distance self._m_has_field_detect_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_distance', None) @property def has_field_pose(self): if hasattr(self, '_m_has_field_pose'): return self._m_has_field_pose self._m_has_field_pose = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_pose', None) class ArrayOfDispConfigAbilityActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigAbilityAction(self._io, self, self._root)) class CoopSelectNodeContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_cond: self.show_cond = Output.CoopCondGroup(self._io, self, self._root) if self.has_field_enable_cond: self.enable_cond = Output.CoopCondGroup(self._io, self, self._root) @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_show_cond(self): if hasattr(self, '_m_has_field_show_cond'): return self._m_has_field_show_cond self._m_has_field_show_cond = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_show_cond', None) @property def has_field_enable_cond(self): if hasattr(self, '_m_has_field_enable_cond'): return self._m_has_field_enable_cond self._m_has_field_enable_cond = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enable_cond', None) class EnableGadgetSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ActivityPlantFlowerMainExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_flower_id_list: self.flower_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_seed_id_list: self.seed_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_wish_flower_kinds: self.max_wish_flower_kinds = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guarantee_start_times: self.guarantee_start_times = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id_list: self.pre_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_quest_id: self.open_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_day: self.content_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_config_id_list: self.daily_config_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_seed_id_list(self): if hasattr(self, '_m_has_field_seed_id_list'): return self._m_has_field_seed_id_list self._m_has_field_seed_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_seed_id_list', None) @property def has_field_pre_quest_id_list(self): if hasattr(self, '_m_has_field_pre_quest_id_list'): return self._m_has_field_pre_quest_id_list self._m_has_field_pre_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_pre_quest_id_list', None) @property def has_field_guarantee_start_times(self): if hasattr(self, '_m_has_field_guarantee_start_times'): return self._m_has_field_guarantee_start_times self._m_has_field_guarantee_start_times = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guarantee_start_times', None) @property def has_field_flower_id_list(self): if hasattr(self, '_m_has_field_flower_id_list'): return self._m_has_field_flower_id_list self._m_has_field_flower_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_flower_id_list', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_daily_config_id_list(self): if hasattr(self, '_m_has_field_daily_config_id_list'): return self._m_has_field_daily_config_id_list self._m_has_field_daily_config_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_daily_config_id_list', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_open_quest_id(self): if hasattr(self, '_m_has_field_open_quest_id'): return self._m_has_field_open_quest_id self._m_has_field_open_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_open_quest_id', None) @property def has_field_content_day(self): if hasattr(self, '_m_has_field_content_day'): return self._m_has_field_content_day self._m_has_field_content_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_content_day', None) @property def has_field_max_wish_flower_kinds(self): if hasattr(self, '_m_has_field_max_wish_flower_kinds'): return self._m_has_field_max_wish_flower_kinds self._m_has_field_max_wish_flower_kinds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_wish_flower_kinds', None) class LampContributionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_contribution: self.contribution = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_contribution(self): if hasattr(self, '_m_has_field_contribution'): return self._m_has_field_contribution self._m_has_field_contribution = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_contribution', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) class EnumRegionShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionShape, self.data.value) return getattr(self, '_m_value', None) class HuntingOfferDifficultyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLocalGadgetSetMaterialCmd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLocalGadgetCmd(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_renderer_name: self.renderer_name = AuxTypes.String(self._io, self, self._root) if self.has_field_prop_name: self.prop_name = AuxTypes.String(self._io, self, self._root) if self.has_field_prop_value: self.prop_value = AuxTypes.String(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_renderer_name(self): if hasattr(self, '_m_has_field_renderer_name'): return self._m_has_field_renderer_name self._m_has_field_renderer_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_renderer_name', None) @property def has_field_prop_value(self): if hasattr(self, '_m_has_field_prop_value'): return self._m_has_field_prop_value self._m_has_field_prop_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_prop_value', None) @property def cmd_exe_type(self): if hasattr(self, '_m_cmd_exe_type'): return self._m_cmd_exe_type self._m_cmd_exe_type = self.base.cmd_exe_type return getattr(self, '_m_cmd_exe_type', None) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_prop_type', None) @property def has_field_prop_name(self): if hasattr(self, '_m_has_field_prop_name'): return self._m_has_field_prop_name self._m_has_field_prop_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_prop_name', None) class LevelTagMapAreaConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_tag_id: self.level_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_area_id: self.map_area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_level_tag_id(self): if hasattr(self, '_m_has_field_level_tag_id'): return self._m_has_field_level_tag_id self._m_has_field_level_tag_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_tag_id', None) @property def has_field_map_area_id(self): if hasattr(self, '_m_has_field_map_area_id'): return self._m_has_field_map_area_id self._m_has_field_map_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_map_area_id', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_index', None) class HealSp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_amount: self.amount = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_caster_max_sp_ratio: self.amount_by_caster_max_sp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_target_max_sp_ratio: self.amount_by_target_max_sp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_current_combo_ratio: self.amount_by_current_combo_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_mute_heal_effect: self.mute_heal_effect = self._io.read_u1() if self.has_field_heal_ratio: self.heal_ratio = self._io.read_f4le() @property def has_field_amount_by_target_max_sp_ratio(self): if hasattr(self, '_m_has_field_amount_by_target_max_sp_ratio'): return self._m_has_field_amount_by_target_max_sp_ratio self._m_has_field_amount_by_target_max_sp_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_amount_by_target_max_sp_ratio', None) @property def has_field_amount(self): if hasattr(self, '_m_has_field_amount'): return self._m_has_field_amount self._m_has_field_amount = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_amount', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_heal_ratio(self): if hasattr(self, '_m_has_field_heal_ratio'): return self._m_has_field_heal_ratio self._m_has_field_heal_ratio = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_heal_ratio', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_mute_heal_effect(self): if hasattr(self, '_m_has_field_mute_heal_effect'): return self._m_has_field_mute_heal_effect self._m_has_field_mute_heal_effect = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_mute_heal_effect', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_amount_by_current_combo_ratio(self): if hasattr(self, '_m_has_field_amount_by_current_combo_ratio'): return self._m_has_field_amount_by_current_combo_ratio self._m_has_field_amount_by_current_combo_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_amount_by_current_combo_ratio', None) @property def has_field_amount_by_caster_max_sp_ratio(self): if hasattr(self, '_m_has_field_amount_by_caster_max_sp_ratio'): return self._m_has_field_amount_by_caster_max_sp_ratio self._m_has_field_amount_by_caster_max_sp_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_amount_by_caster_max_sp_ratio', None) class EnumActionPointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionPointType, self.data.value) return getattr(self, '_m_value', None) class EnumDieStateFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DieStateFlag, self.data.value) return getattr(self, '_m_value', None) class ByAnimatorInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicInt(self._io, self, self._root) if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_parameter', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class KvpOfDictEnumElementTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementType(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class RoutineCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TdPlayTowerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetCondenseResin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_replace_resin_count: self.replace_resin_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_replace_resin_count(self): if hasattr(self, '_m_has_field_replace_resin_count'): return self._m_has_field_replace_resin_count self._m_has_field_replace_resin_count = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_replace_resin_count', None) class RoomWeatherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAnimatorTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AnimatorTrigger(self._io, self, self._root)) class SetPoseInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_int_id: self.int_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def has_field_int_id(self): if hasattr(self, '_m_has_field_int_id'): return self._m_has_field_int_id self._m_has_field_int_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_id', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigInputHint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hint_info: self.hint_info = AuxTypes.String(self._io, self, self._root) if self.has_field_action_info_list: self.action_info_list = Output.ArrayOfEnumInputActionTypeLengthU(self._io, self, self._root) @property def has_field_hint_info(self): if hasattr(self, '_m_has_field_hint_info'): return self._m_has_field_hint_info self._m_has_field_hint_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hint_info', None) @property def has_field_action_info_list(self): if hasattr(self, '_m_has_field_action_info_list'): return self._m_has_field_action_info_list self._m_has_field_action_info_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_info_list', None) class FireEffectForStorm(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFishingFleeData(self._io, self, self._root) class ConfigShapeSector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_full_degree: self.full_degree = self._io.read_f4le() @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_full_degree(self): if hasattr(self, '_m_has_field_full_degree'): return self._m_has_field_full_degree self._m_has_field_full_degree = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_full_degree', None) class HideAndSeekSkillCategoryComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBaseInputEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_action_type: self.action_type = Output.EnumInputActionType(self._io, self, self._root) if self.has_field_action_event: self.action_event = Output.EnumActionEventType(self._io, self, self._root) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_type', None) @property def has_field_action_event(self): if hasattr(self, '_m_has_field_action_event'): return self._m_has_field_action_event self._m_has_field_action_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_event', None) class ActivityHachiFinalStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_title: self.quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_title: self.boss_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_desc: self.boss_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_final_quest_id: self.final_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_boss_desc(self): if hasattr(self, '_m_has_field_boss_desc'): return self._m_has_field_boss_desc self._m_has_field_boss_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_boss_desc', None) @property def has_field_boss_title(self): if hasattr(self, '_m_has_field_boss_title'): return self._m_has_field_boss_title self._m_has_field_boss_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_boss_title', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_quest_title(self): if hasattr(self, '_m_has_field_quest_title'): return self._m_has_field_quest_title self._m_has_field_quest_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_title', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_final_quest_id(self): if hasattr(self, '_m_has_field_final_quest_id'): return self._m_has_field_final_quest_id self._m_has_field_final_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_final_quest_id', None) class ConfigWidgetGadgetBuilder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height_to_avatar: self.height_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_check_collision: self.check_collision = self._io.read_u1() @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def has_field_height_to_avatar(self): if hasattr(self, '_m_has_field_height_to_avatar'): return self._m_has_field_height_to_avatar self._m_has_field_height_to_avatar = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_height_to_avatar', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_check_collision(self): if hasattr(self, '_m_has_field_check_collision'): return self._m_has_field_check_collision self._m_has_field_check_collision = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_check_collision', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class RewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hcoin: self.hcoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scoin: self.scoin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_exp: self.player_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_exp: self.avatar_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_exp: self.fetter_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resin: self.resin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_item_list: self.reward_item_list = Output.ArrayOfRewardItemConfigLengthS(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_avatar_exp(self): if hasattr(self, '_m_has_field_avatar_exp'): return self._m_has_field_avatar_exp self._m_has_field_avatar_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_avatar_exp', None) @property def has_field_scoin(self): if hasattr(self, '_m_has_field_scoin'): return self._m_has_field_scoin self._m_has_field_scoin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scoin', None) @property def has_field_hcoin(self): if hasattr(self, '_m_has_field_hcoin'): return self._m_has_field_hcoin self._m_has_field_hcoin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hcoin', None) @property def has_field_fetter_exp(self): if hasattr(self, '_m_has_field_fetter_exp'): return self._m_has_field_fetter_exp self._m_has_field_fetter_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fetter_exp', None) @property def has_field_player_exp(self): if hasattr(self, '_m_has_field_player_exp'): return self._m_has_field_player_exp self._m_has_field_player_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_player_exp', None) @property def has_field_resin(self): if hasattr(self, '_m_has_field_resin'): return self._m_has_field_resin self._m_has_field_resin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_resin', None) @property def has_field_reward_item_list(self): if hasattr(self, '_m_has_field_reward_item_list'): return self._m_has_field_reward_item_list self._m_has_field_reward_item_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_reward_item_list', None) class EnumWatcherTriggerTraceBackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WatcherTriggerTraceBackType, self.data.value) return getattr(self, '_m_value', None) class ShieldBarMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_shield_broken: self.on_shield_broken = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_revert: self.revert = self._io.read_u1() if self.has_field_show_damage_text: self.show_damage_text = AuxTypes.String(self._io, self, self._root) if self.has_field_use_muti_player_fix_data: self.use_muti_player_fix_data = self._io.read_u1() @property def has_field_on_shield_broken(self): if hasattr(self, '_m_has_field_on_shield_broken'): return self._m_has_field_on_shield_broken self._m_has_field_on_shield_broken = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_shield_broken', None) @property def has_field_revert(self): if hasattr(self, '_m_has_field_revert'): return self._m_has_field_revert self._m_has_field_revert = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_revert', None) @property def has_field_show_damage_text(self): if hasattr(self, '_m_has_field_show_damage_text'): return self._m_has_field_show_damage_text self._m_has_field_show_damage_text = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_show_damage_text', None) @property def has_field_use_muti_player_fix_data(self): if hasattr(self, '_m_has_field_use_muti_player_fix_data'): return self._m_has_field_use_muti_player_fix_data self._m_has_field_use_muti_player_fix_data = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_muti_player_fix_data', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class TutorialDetailExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumTutorialDetailType(self._io, self, self._root) if self.has_field_image_name_list: self.image_name_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_descript: self.descript = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_image_name_list(self): if hasattr(self, '_m_has_field_image_name_list'): return self._m_has_field_image_name_list self._m_has_field_image_name_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_image_name_list', None) @property def has_field_descript(self): if hasattr(self, '_m_has_field_descript'): return self._m_has_field_descript self._m_has_field_descript = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_descript', None) class RefreshPolicyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumProgressShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProgressShowType, self.data.value) return getattr(self, '_m_value', None) class MechanicusCardTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigAudioEventCullingRuleBaseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigAudioEventCullingRuleBase(self._io, self, self._root)) class ConfigAiSpacialFacingMoveProbability(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stop: self.stop = self._io.read_f4le() if self.has_field_forward: self.forward = self._io.read_f4le() if self.has_field_right: self.right = self._io.read_f4le() if self.has_field_up: self.up = self._io.read_f4le() if self.has_field_forward_min: self.forward_min = self._io.read_f4le() if self.has_field_forward_max: self.forward_max = self._io.read_f4le() if self.has_field_back_min: self.back_min = self._io.read_f4le() if self.has_field_back_max: self.back_max = self._io.read_f4le() if self.has_field_right_min: self.right_min = self._io.read_f4le() if self.has_field_right_max: self.right_max = self._io.read_f4le() if self.has_field_left_min: self.left_min = self._io.read_f4le() if self.has_field_left_max: self.left_max = self._io.read_f4le() if self.has_field_up_min: self.up_min = self._io.read_f4le() if self.has_field_up_max: self.up_max = self._io.read_f4le() if self.has_field_down_min: self.down_min = self._io.read_f4le() if self.has_field_down_max: self.down_max = self._io.read_f4le() if self.has_field_best_height: self.best_height = self._io.read_f4le() if self.has_field_min_height: self.min_height = self._io.read_f4le() if self.has_field_max_height: self.max_height = self._io.read_f4le() @property def has_field_back_max(self): if hasattr(self, '_m_has_field_back_max'): return self._m_has_field_back_max self._m_has_field_back_max = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_back_max', None) @property def has_field_forward(self): if hasattr(self, '_m_has_field_forward'): return self._m_has_field_forward self._m_has_field_forward = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_forward', None) @property def has_field_up(self): if hasattr(self, '_m_has_field_up'): return self._m_has_field_up self._m_has_field_up = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_up', None) @property def has_field_forward_max(self): if hasattr(self, '_m_has_field_forward_max'): return self._m_has_field_forward_max self._m_has_field_forward_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_forward_max', None) @property def has_field_forward_min(self): if hasattr(self, '_m_has_field_forward_min'): return self._m_has_field_forward_min self._m_has_field_forward_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_forward_min', None) @property def has_field_down_max(self): if hasattr(self, '_m_has_field_down_max'): return self._m_has_field_down_max self._m_has_field_down_max = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_down_max', None) @property def has_field_right_min(self): if hasattr(self, '_m_has_field_right_min'): return self._m_has_field_right_min self._m_has_field_right_min = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_right_min', None) @property def has_field_left_min(self): if hasattr(self, '_m_has_field_left_min'): return self._m_has_field_left_min self._m_has_field_left_min = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_left_min', None) @property def has_field_left_max(self): if hasattr(self, '_m_has_field_left_max'): return self._m_has_field_left_max self._m_has_field_left_max = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_left_max', None) @property def has_field_down_min(self): if hasattr(self, '_m_has_field_down_min'): return self._m_has_field_down_min self._m_has_field_down_min = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_down_min', None) @property def has_field_right(self): if hasattr(self, '_m_has_field_right'): return self._m_has_field_right self._m_has_field_right = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_right', None) @property def has_field_up_max(self): if hasattr(self, '_m_has_field_up_max'): return self._m_has_field_up_max self._m_has_field_up_max = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_up_max', None) @property def has_field_back_min(self): if hasattr(self, '_m_has_field_back_min'): return self._m_has_field_back_min self._m_has_field_back_min = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_back_min', None) @property def has_field_up_min(self): if hasattr(self, '_m_has_field_up_min'): return self._m_has_field_up_min self._m_has_field_up_min = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_up_min', None) @property def has_field_max_height(self): if hasattr(self, '_m_has_field_max_height'): return self._m_has_field_max_height self._m_has_field_max_height = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_max_height', None) @property def has_field_best_height(self): if hasattr(self, '_m_has_field_best_height'): return self._m_has_field_best_height self._m_has_field_best_height = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_best_height', None) @property def has_field_min_height(self): if hasattr(self, '_m_has_field_min_height'): return self._m_has_field_min_height self._m_has_field_min_height = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_min_height', None) @property def has_field_stop(self): if hasattr(self, '_m_has_field_stop'): return self._m_has_field_stop self._m_has_field_stop = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_stop', None) @property def has_field_right_max(self): if hasattr(self, '_m_has_field_right_max'): return self._m_has_field_right_max self._m_has_field_right_max = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_right_max', None) class MotionBlurQualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetStateDisableRadarHint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class BartenderLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FishSkillCategoryComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NativeDynamicAllocator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChallengeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChessCardEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumChessCardTargetType(self._io, self, self._root) if self.has_field_target_param_list: self.target_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumChessCardEffectType(self._io, self, self._root) if self.has_field_effect_str_param: self.effect_str_param = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_param1: self.effect_param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param2: self.effect_param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param3: self.effect_param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_begin_round: self.begin_round = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_active_rounds: self.active_rounds = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_index: self.effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_effect_str_param(self): if hasattr(self, '_m_has_field_effect_str_param'): return self._m_has_field_effect_str_param self._m_has_field_effect_str_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effect_str_param', None) @property def has_field_effect_param3(self): if hasattr(self, '_m_has_field_effect_param3'): return self._m_has_field_effect_param3 self._m_has_field_effect_param3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_effect_param3', None) @property def has_field_effect_param1(self): if hasattr(self, '_m_has_field_effect_param1'): return self._m_has_field_effect_param1 self._m_has_field_effect_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effect_param1', None) @property def has_field_begin_round(self): if hasattr(self, '_m_has_field_begin_round'): return self._m_has_field_begin_round self._m_has_field_begin_round = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_begin_round', None) @property def has_field_active_rounds(self): if hasattr(self, '_m_has_field_active_rounds'): return self._m_has_field_active_rounds self._m_has_field_active_rounds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_active_rounds', None) @property def has_field_target_param_list(self): if hasattr(self, '_m_has_field_target_param_list'): return self._m_has_field_target_param_list self._m_has_field_target_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_target_param_list', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_target_type', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_effect_index', None) @property def has_field_effect_param2(self): if hasattr(self, '_m_has_field_effect_param2'): return self._m_has_field_effect_param2 self._m_has_field_effect_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_param2', None) class DictOfAuxTypesVlqBase128LeSF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSF4(self._io, self, self._root)) class EnumFoodQualityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FoodQualityType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfRogueGadgetStateConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RogueGadgetStateConfig(self._io, self, self._root)) class EnumMarkVisibleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkVisibleType, self.data.value) return getattr(self, '_m_value', None) class ConfigHomeworldFurnitureLightDetail(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_light_path: self.light_path = AuxTypes.String(self._io, self, self._root) if self.has_field_light_component: self.light_component = Output.ConfigHomeworldFurnitureLightComponent(self._io, self, self._root) if self.has_field_enviro_component: self.enviro_component = Output.ConfigHomeworldFurnitureEnviroComponent(self._io, self, self._root) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_enviro_component(self): if hasattr(self, '_m_has_field_enviro_component'): return self._m_has_field_enviro_component self._m_has_field_enviro_component = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_enviro_component', None) @property def has_field_light_path(self): if hasattr(self, '_m_has_field_light_path'): return self._m_has_field_light_path self._m_has_field_light_path = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_light_path', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_light_component(self): if hasattr(self, '_m_has_field_light_component'): return self._m_has_field_light_component self._m_has_field_light_component = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_light_component', None) class BartenderLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_duration: self.level_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_list: self.order_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_order_cd: self.order_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_description: self.level_description = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level_description(self): if hasattr(self, '_m_has_field_level_description'): return self._m_has_field_level_description self._m_has_field_level_description = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_level_description', None) @property def has_field_order_cd(self): if hasattr(self, '_m_has_field_order_cd'): return self._m_has_field_order_cd self._m_has_field_order_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_order_cd', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_level_duration(self): if hasattr(self, '_m_has_field_level_duration'): return self._m_has_field_level_duration self._m_has_field_level_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_duration', None) @property def has_field_order_list(self): if hasattr(self, '_m_has_field_order_list'): return self._m_has_field_order_list self._m_has_field_order_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_order_list', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigGear(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gear_type: self.gear_type = Output.EnumGearType(self._io, self, self._root) if self.has_field_start_elem_type: self.start_elem_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_start_value: self.start_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_last_time: self.start_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stop_elem_type: self.stop_elem_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_stop_value: self.stop_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stop_last_time: self.stop_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stop_elem_type(self): if hasattr(self, '_m_has_field_stop_elem_type'): return self._m_has_field_stop_elem_type self._m_has_field_stop_elem_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_stop_elem_type', None) @property def has_field_stop_value(self): if hasattr(self, '_m_has_field_stop_value'): return self._m_has_field_stop_value self._m_has_field_stop_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_stop_value', None) @property def has_field_gear_type(self): if hasattr(self, '_m_has_field_gear_type'): return self._m_has_field_gear_type self._m_has_field_gear_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gear_type', None) @property def has_field_start_elem_type(self): if hasattr(self, '_m_has_field_start_elem_type'): return self._m_has_field_start_elem_type self._m_has_field_start_elem_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_elem_type', None) @property def has_field_start_last_time(self): if hasattr(self, '_m_has_field_start_last_time'): return self._m_has_field_start_last_time self._m_has_field_start_last_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_start_last_time', None) @property def has_field_start_value(self): if hasattr(self, '_m_has_field_start_value'): return self._m_has_field_start_value self._m_has_field_start_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_start_value', None) @property def has_field_stop_last_time(self): if hasattr(self, '_m_has_field_stop_last_time'): return self._m_has_field_stop_last_time self._m_has_field_stop_last_time = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_stop_last_time', None) class ActivityGroupLinkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetCameraExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_distance: self.hint_distance = self._io.read_f4le() if self.has_field_ui_path: self.ui_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tips: self.tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scan_tips: self.scan_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scan_success_desc: self.scan_success_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_hint_distance(self): if hasattr(self, '_m_has_field_hint_distance'): return self._m_has_field_hint_distance self._m_has_field_hint_distance = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hint_distance', None) @property def has_field_tips(self): if hasattr(self, '_m_has_field_tips'): return self._m_has_field_tips self._m_has_field_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tips', None) @property def has_field_scan_tips(self): if hasattr(self, '_m_has_field_scan_tips'): return self._m_has_field_scan_tips self._m_has_field_scan_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_scan_tips', None) @property def has_field_ui_path(self): if hasattr(self, '_m_has_field_ui_path'): return self._m_has_field_ui_path self._m_has_field_ui_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ui_path', None) @property def has_field_scan_success_desc(self): if hasattr(self, '_m_has_field_scan_success_desc'): return self._m_has_field_scan_success_desc self._m_has_field_scan_success_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_scan_success_desc', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class SceneTransPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_max_spring_volume: self.max_spring_volume = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cutscene_list: self.cutscene_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_forbid_avatar_revive: self.is_forbid_avatar_revive = self._io.read_u1() if self.has_field_is_forbid_avatar_auto_use_spring: self.is_forbid_avatar_auto_use_spring = self._io.read_u1() if self.has_field_map_visibility: self.map_visibility = Output.EnumPointMapVisibility(self._io, self, self._root) if self.has_field_show_on_locked_area: self.show_on_locked_area = self._io.read_u1() if self.has_field_disable_interaction: self.disable_interaction = self._io.read_u1() @property def has_field_is_forbid_avatar_auto_use_spring(self): if hasattr(self, '_m_has_field_is_forbid_avatar_auto_use_spring'): return self._m_has_field_is_forbid_avatar_auto_use_spring self._m_has_field_is_forbid_avatar_auto_use_spring = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_forbid_avatar_auto_use_spring', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def has_field_is_forbid_avatar_revive(self): if hasattr(self, '_m_has_field_is_forbid_avatar_revive'): return self._m_has_field_is_forbid_avatar_revive self._m_has_field_is_forbid_avatar_revive = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_forbid_avatar_revive', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_max_spring_volume(self): if hasattr(self, '_m_has_field_max_spring_volume'): return self._m_has_field_max_spring_volume self._m_has_field_max_spring_volume = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_spring_volume', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def has_field_cutscene_list(self): if hasattr(self, '_m_has_field_cutscene_list'): return self._m_has_field_cutscene_list self._m_has_field_cutscene_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cutscene_list', None) @property def has_field_map_visibility(self): if hasattr(self, '_m_has_field_map_visibility'): return self._m_has_field_map_visibility self._m_has_field_map_visibility = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_map_visibility', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_disable_interaction(self): if hasattr(self, '_m_has_field_disable_interaction'): return self._m_has_field_disable_interaction self._m_has_field_disable_interaction = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_disable_interaction', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_npc_id', None) @property def has_field_show_on_locked_area(self): if hasattr(self, '_m_has_field_show_on_locked_area'): return self._m_has_field_show_on_locked_area self._m_has_field_show_on_locked_area = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_show_on_locked_area', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class KvpOfDictAuxTypesVlqBase128LeUConfigSceneMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigSceneMeta(self._io, self, self._root) class EntityDitherMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_dither_value: self.dither_value = self._io.read_f4le() if self.has_field_cut_in_time: self.cut_in_time = self._io.read_f4le() if self.has_field_cut_out_time: self.cut_out_time = self._io.read_f4le() if self.has_field_force_update_at_start: self.force_update_at_start = self._io.read_u1() @property def has_field_force_update_at_start(self): if hasattr(self, '_m_has_field_force_update_at_start'): return self._m_has_field_force_update_at_start self._m_has_field_force_update_at_start = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_force_update_at_start', None) @property def has_field_dither_value(self): if hasattr(self, '_m_has_field_dither_value'): return self._m_has_field_dither_value self._m_has_field_dither_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dither_value', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_cut_out_time(self): if hasattr(self, '_m_has_field_cut_out_time'): return self._m_has_field_cut_out_time self._m_has_field_cut_out_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cut_out_time', None) @property def has_field_cut_in_time(self): if hasattr(self, '_m_has_field_cut_in_time'): return self._m_has_field_cut_in_time self._m_has_field_cut_in_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cut_in_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class CompoundTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioWeatherVoTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weather_type_list: self.weather_type_list = Output.ArrayOfEnumConfigWeatherTypeLengthU(self._io, self, self._root) if self.has_field_weather_type_is_include: self.weather_type_is_include = self._io.read_u1() if self.has_field_weather_list: self.weather_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_weather_is_include: self.weather_is_include = self._io.read_u1() if self.has_field_previous_weather_type_list: self.previous_weather_type_list = Output.ArrayOfEnumConfigWeatherTypeLengthU(self._io, self, self._root) if self.has_field_previous_weather_type_is_include: self.previous_weather_type_is_include = self._io.read_u1() if self.has_field_previous_weather_list: self.previous_weather_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_previous_weather_is_include: self.previous_weather_is_include = self._io.read_u1() if self.has_field_vo_trigger: self.vo_trigger = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_time_limit: self.time_limit = Output.ArrayOfAudioWeatherVoTriggerTimeRuleLengthU(self._io, self, self._root) @property def has_field_weather_is_include(self): if hasattr(self, '_m_has_field_weather_is_include'): return self._m_has_field_weather_is_include self._m_has_field_weather_is_include = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_weather_is_include', None) @property def has_field_previous_weather_type_is_include(self): if hasattr(self, '_m_has_field_previous_weather_type_is_include'): return self._m_has_field_previous_weather_type_is_include self._m_has_field_previous_weather_type_is_include = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_previous_weather_type_is_include', None) @property def has_field_previous_weather_is_include(self): if hasattr(self, '_m_has_field_previous_weather_is_include'): return self._m_has_field_previous_weather_is_include self._m_has_field_previous_weather_is_include = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_previous_weather_is_include', None) @property def has_field_time_limit(self): if hasattr(self, '_m_has_field_time_limit'): return self._m_has_field_time_limit self._m_has_field_time_limit = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_time_limit', None) @property def has_field_weather_list(self): if hasattr(self, '_m_has_field_weather_list'): return self._m_has_field_weather_list self._m_has_field_weather_list = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_weather_list', None) @property def has_field_weather_type_list(self): if hasattr(self, '_m_has_field_weather_type_list'): return self._m_has_field_weather_type_list self._m_has_field_weather_type_list = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_weather_type_list', None) @property def has_field_previous_weather_type_list(self): if hasattr(self, '_m_has_field_previous_weather_type_list'): return self._m_has_field_previous_weather_type_list self._m_has_field_previous_weather_type_list = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_previous_weather_type_list', None) @property def has_field_vo_trigger(self): if hasattr(self, '_m_has_field_vo_trigger'): return self._m_has_field_vo_trigger self._m_has_field_vo_trigger = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_vo_trigger', None) @property def has_field_previous_weather_list(self): if hasattr(self, '_m_has_field_previous_weather_list'): return self._m_has_field_previous_weather_list self._m_has_field_previous_weather_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_previous_weather_list', None) @property def has_field_weather_type_is_include(self): if hasattr(self, '_m_has_field_weather_type_is_include'): return self._m_has_field_weather_type_is_include self._m_has_field_weather_type_is_include = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_weather_type_is_include', None) class EnumLogicType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LogicType, self.data.value) return getattr(self, '_m_value', None) class EnumAnimatorParamType2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimatorParamType2, self.data.value) return getattr(self, '_m_value', None) class EnumSalvagePlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SalvagePlayType, self.data.value) return getattr(self, '_m_value', None) class DoBlink(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class OpActivityBonusSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChessCardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioUiSupport(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_combo_rtpc_key: self.combo_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_countdown: self.countdown = self._io.read_f4le() @property def has_field_combo_rtpc_key(self): if hasattr(self, '_m_has_field_combo_rtpc_key'): return self._m_has_field_combo_rtpc_key self._m_has_field_combo_rtpc_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_combo_rtpc_key', None) @property def has_field_countdown(self): if hasattr(self, '_m_has_field_countdown'): return self._m_has_field_countdown self._m_has_field_countdown = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_countdown', None) class PhotographCheckAnimatorData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entity_config_id: self.entity_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_animator_list: self.animator_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_animator_tag_list: self.animator_tag_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_entity_config_id(self): if hasattr(self, '_m_has_field_entity_config_id'): return self._m_has_field_entity_config_id self._m_has_field_entity_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_entity_config_id', None) @property def has_field_animator_list(self): if hasattr(self, '_m_has_field_animator_list'): return self._m_has_field_animator_list self._m_has_field_animator_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_animator_list', None) @property def has_field_animator_tag_list(self): if hasattr(self, '_m_has_field_animator_tag_list'): return self._m_has_field_animator_tag_list self._m_has_field_animator_tag_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_animator_tag_list', None) class ReliquaryDecomposeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_reliquary_count: self.need_reliquary_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_reliquary_rank_level: self.need_reliquary_rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_reliquary_num: self.max_reliquary_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_desc: self.effect_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_max_reliquary_num(self): if hasattr(self, '_m_has_field_max_reliquary_num'): return self._m_has_field_max_reliquary_num self._m_has_field_max_reliquary_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_reliquary_num', None) @property def has_field_effect_desc(self): if hasattr(self, '_m_has_field_effect_desc'): return self._m_has_field_effect_desc self._m_has_field_effect_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_desc', None) @property def has_field_need_reliquary_rank_level(self): if hasattr(self, '_m_has_field_need_reliquary_rank_level'): return self._m_has_field_need_reliquary_rank_level self._m_has_field_need_reliquary_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_need_reliquary_rank_level', None) @property def has_field_need_reliquary_count(self): if hasattr(self, '_m_has_field_need_reliquary_count'): return self._m_has_field_need_reliquary_count self._m_has_field_need_reliquary_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_need_reliquary_count', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigPreloadTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeworldAnimalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_rebirth: self.is_rebirth = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rebirth_cd: self.rebirth_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_is_rebirth(self): if hasattr(self, '_m_has_field_is_rebirth'): return self._m_has_field_is_rebirth self._m_has_field_is_rebirth = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_rebirth', None) @property def has_field_rebirth_cd(self): if hasattr(self, '_m_has_field_rebirth_cd'): return self._m_has_field_rebirth_cd self._m_has_field_rebirth_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_rebirth_cd', None) class ArrayOfWorldAreaLevelupActionLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.WorldAreaLevelupAction(self._io, self, self._root)) class EnumComponentTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ComponentTag, self.data.value) return getattr(self, '_m_value', None) class ItemTypeEqualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestGuide(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestGuideType(self._io, self, self._root) if self.has_field_auto_guide: self.auto_guide = Output.EnumQuestGuideAuto(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_guide_scene: self.guide_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_style: self.guide_style = Output.EnumQuestGuideStyle(self._io, self, self._root) if self.has_field_guide_layer: self.guide_layer = Output.EnumQuestGuideLayer(self._io, self, self._root) @property def has_field_guide_layer(self): if hasattr(self, '_m_has_field_guide_layer'): return self._m_has_field_guide_layer self._m_has_field_guide_layer = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guide_layer', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_guide_style(self): if hasattr(self, '_m_has_field_guide_style'): return self._m_has_field_guide_style self._m_has_field_guide_style = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_guide_style', None) @property def has_field_auto_guide(self): if hasattr(self, '_m_has_field_auto_guide'): return self._m_has_field_auto_guide self._m_has_field_auto_guide = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_auto_guide', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_guide_scene(self): if hasattr(self, '_m_has_field_guide_scene'): return self._m_has_field_guide_scene self._m_has_field_guide_scene = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_guide_scene', None) class EnumWorldAreaLevelupActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WorldAreaLevelupActionType, self.data.value) return getattr(self, '_m_value', None) class BagTabComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetToyAbilityGroupGenerator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_team: self.is_team = self._io.read_u1() @property def has_field_is_team(self): if hasattr(self, '_m_has_field_is_team'): return self._m_has_field_is_team self._m_has_field_is_team = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_team', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class ReviseLevelGrowExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigKeyCodeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChessCardQualityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardQualityType, self.data.value) return getattr(self, '_m_value', None) class ElementTypeModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) class EnumQuestCondCompareType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestCondCompareType, self.data.value) return getattr(self, '_m_value', None) class ConfigCustomLevelRoomSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_room_id: self.room_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_limit_config: self.component_limit_config = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_init_pos: self.player_init_pos = Output.Vector(self._io, self, self._root) if self.has_field_player_init_rot: self.player_init_rot = Output.Vector(self._io, self, self._root) if self.has_field_basic_data: self.basic_data = Output.ConfigCustomLevelRoomBasic(self._io, self, self._root) if self.has_field_extra_data: self.extra_data = Output.ArrayOfConfigCustomLevelRoomExtraDataLengthU(self._io, self, self._root) @property def has_field_extra_data(self): if hasattr(self, '_m_has_field_extra_data'): return self._m_has_field_extra_data self._m_has_field_extra_data = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_extra_data', None) @property def has_field_player_init_pos(self): if hasattr(self, '_m_has_field_player_init_pos'): return self._m_has_field_player_init_pos self._m_has_field_player_init_pos = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_player_init_pos', None) @property def has_field_room_id(self): if hasattr(self, '_m_has_field_room_id'): return self._m_has_field_room_id self._m_has_field_room_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_room_id', None) @property def has_field_basic_data(self): if hasattr(self, '_m_has_field_basic_data'): return self._m_has_field_basic_data self._m_has_field_basic_data = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_basic_data', None) @property def has_field_player_init_rot(self): if hasattr(self, '_m_has_field_player_init_rot'): return self._m_has_field_player_init_rot self._m_has_field_player_init_rot = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_player_init_rot', None) @property def has_field_component_limit_config(self): if hasattr(self, '_m_has_field_component_limit_config'): return self._m_has_field_component_limit_config self._m_has_field_component_limit_config = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_component_limit_config', None) class EnumPlayMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlayMode, self.data.value) return getattr(self, '_m_value', None) class ConfigCutsceneInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cutscene_cfg: self.cutscene_cfg = Output.DispConfigBaseCutscene(self._io, self, self._root) if self.has_field_cutscene_index: self.cutscene_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sync_load: self.sync_load = self._io.read_u1() @property def has_field_sync_load(self): if hasattr(self, '_m_has_field_sync_load'): return self._m_has_field_sync_load self._m_has_field_sync_load = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sync_load', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_cutscene_index(self): if hasattr(self, '_m_has_field_cutscene_index'): return self._m_has_field_cutscene_index self._m_has_field_cutscene_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cutscene_index', None) @property def has_field_cutscene_cfg(self): if hasattr(self, '_m_has_field_cutscene_cfg'): return self._m_has_field_cutscene_cfg self._m_has_field_cutscene_cfg = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cutscene_cfg', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class DoReviveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) if self.has_field_ignore_die_abyss: self.ignore_die_abyss = self._io.read_u1() if self.has_field_ignore_die_drawn: self.ignore_die_drawn = self._io.read_u1() if self.has_field_on_kill_actions: self.on_kill_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_revive_actions: self.on_revive_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_ignore_die_abyss(self): if hasattr(self, '_m_has_field_ignore_die_abyss'): return self._m_has_field_ignore_die_abyss self._m_has_field_ignore_die_abyss = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ignore_die_abyss', None) @property def has_field_on_kill_actions(self): if hasattr(self, '_m_has_field_on_kill_actions'): return self._m_has_field_on_kill_actions self._m_has_field_on_kill_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_kill_actions', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_on_revive_actions(self): if hasattr(self, '_m_has_field_on_revive_actions'): return self._m_has_field_on_revive_actions self._m_has_field_on_revive_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_revive_actions', None) @property def has_field_ignore_die_drawn(self): if hasattr(self, '_m_has_field_ignore_die_drawn'): return self._m_has_field_ignore_die_drawn self._m_has_field_ignore_die_drawn = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ignore_die_drawn', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ButtonHoldChargeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_charge_time: self.charge_time = self._io.read_f4le() if self.has_field_second_charge_time: self.second_charge_time = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_on_begin_uncharged: self.on_begin_uncharged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_release_uncharged: self.on_release_uncharged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_begin_charged: self.on_begin_charged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_release_charged: self.on_release_charged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_begin_second_charged: self.on_begin_second_charged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_release_second_charged: self.on_release_second_charged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_cancel_charged: self.on_cancel_charged = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_charge_state_i_ds: self.charge_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_on_begin_uncharged(self): if hasattr(self, '_m_has_field_on_begin_uncharged'): return self._m_has_field_on_begin_uncharged self._m_has_field_on_begin_uncharged = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_on_begin_uncharged', None) @property def has_field_charge_state_i_ds(self): if hasattr(self, '_m_has_field_charge_state_i_ds'): return self._m_has_field_charge_state_i_ds self._m_has_field_charge_state_i_ds = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_charge_state_i_ds', None) @property def has_field_on_cancel_charged(self): if hasattr(self, '_m_has_field_on_cancel_charged'): return self._m_has_field_on_cancel_charged self._m_has_field_on_cancel_charged = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_on_cancel_charged', None) @property def has_field_on_release_second_charged(self): if hasattr(self, '_m_has_field_on_release_second_charged'): return self._m_has_field_on_release_second_charged self._m_has_field_on_release_second_charged = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_on_release_second_charged', None) @property def has_field_second_charge_time(self): if hasattr(self, '_m_has_field_second_charge_time'): return self._m_has_field_second_charge_time self._m_has_field_second_charge_time = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_second_charge_time', None) @property def has_field_charge_time(self): if hasattr(self, '_m_has_field_charge_time'): return self._m_has_field_charge_time self._m_has_field_charge_time = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_charge_time', None) @property def has_field_on_begin_charged(self): if hasattr(self, '_m_has_field_on_begin_charged'): return self._m_has_field_on_begin_charged self._m_has_field_on_begin_charged = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_on_begin_charged', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_on_release_charged(self): if hasattr(self, '_m_has_field_on_release_charged'): return self._m_has_field_on_release_charged self._m_has_field_on_release_charged = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_release_charged', None) @property def has_field_on_begin_second_charged(self): if hasattr(self, '_m_has_field_on_begin_second_charged'): return self._m_has_field_on_begin_second_charged self._m_has_field_on_begin_second_charged = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_begin_second_charged', None) @property def has_field_on_release_uncharged(self): if hasattr(self, '_m_has_field_on_release_uncharged'): return self._m_has_field_on_release_uncharged self._m_has_field_on_release_uncharged = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_on_release_uncharged', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumGuideNavigationCheckType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideNavigationCheckType, self.data.value) return getattr(self, '_m_value', None) class InputActionGroupTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfMonsterDropLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MonsterDrop(self._io, self, self._root)) class ConfigAiMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_move_category: self.move_category = Output.EnumMoveCategoryAi(self._io, self, self._root) if self.has_field_use_nav_mesh: self.use_nav_mesh = self._io.read_u1() if self.has_field_nav_mesh_agent_name: self.nav_mesh_agent_name = AuxTypes.String(self._io, self, self._root) if self.has_field_almost_reached_distance_walk: self.almost_reached_distance_walk = self._io.read_f4le() if self.has_field_almost_reached_distance_run: self.almost_reached_distance_run = self._io.read_f4le() if self.has_field_snakelike_move_setting: self.snakelike_move_setting = Output.ConfigAiSnakelikeMove(self._io, self, self._root) @property def has_field_nav_mesh_agent_name(self): if hasattr(self, '_m_has_field_nav_mesh_agent_name'): return self._m_has_field_nav_mesh_agent_name self._m_has_field_nav_mesh_agent_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_nav_mesh_agent_name', None) @property def has_field_almost_reached_distance_run(self): if hasattr(self, '_m_has_field_almost_reached_distance_run'): return self._m_has_field_almost_reached_distance_run self._m_has_field_almost_reached_distance_run = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_almost_reached_distance_run', None) @property def has_field_use_nav_mesh(self): if hasattr(self, '_m_has_field_use_nav_mesh'): return self._m_has_field_use_nav_mesh self._m_has_field_use_nav_mesh = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_nav_mesh', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_almost_reached_distance_walk(self): if hasattr(self, '_m_has_field_almost_reached_distance_walk'): return self._m_has_field_almost_reached_distance_walk self._m_has_field_almost_reached_distance_walk = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_almost_reached_distance_walk', None) @property def has_field_snakelike_move_setting(self): if hasattr(self, '_m_has_field_snakelike_move_setting'): return self._m_has_field_snakelike_move_setting self._m_has_field_snakelike_move_setting = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_snakelike_move_setting', None) @property def has_field_move_category(self): if hasattr(self, '_m_has_field_move_category'): return self._m_has_field_move_category self._m_has_field_move_category = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_move_category', None) class AvatarTalentExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_talent_id: self.talent_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_prev_talent: self.prev_talent = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_cost_item_id: self.main_cost_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_cost_item_count: self.main_cost_item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vice_cost_item_id: self.vice_cost_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vice_cost_item_count: self.vice_cost_item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_config: self.open_config = AuxTypes.String(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_open_config(self): if hasattr(self, '_m_has_field_open_config'): return self._m_has_field_open_config self._m_has_field_open_config = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_config', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_param_list', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_main_cost_item_id(self): if hasattr(self, '_m_has_field_main_cost_item_id'): return self._m_has_field_main_cost_item_id self._m_has_field_main_cost_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_main_cost_item_id', None) @property def has_field_prev_talent(self): if hasattr(self, '_m_has_field_prev_talent'): return self._m_has_field_prev_talent self._m_has_field_prev_talent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_prev_talent', None) @property def has_field_vice_cost_item_count(self): if hasattr(self, '_m_has_field_vice_cost_item_count'): return self._m_has_field_vice_cost_item_count self._m_has_field_vice_cost_item_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_vice_cost_item_count', None) @property def has_field_talent_id(self): if hasattr(self, '_m_has_field_talent_id'): return self._m_has_field_talent_id self._m_has_field_talent_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_talent_id', None) @property def has_field_vice_cost_item_id(self): if hasattr(self, '_m_has_field_vice_cost_item_id'): return self._m_has_field_vice_cost_item_id self._m_has_field_vice_cost_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_vice_cost_item_id', None) @property def has_field_main_cost_item_count(self): if hasattr(self, '_m_has_field_main_cost_item_count'): return self._m_has_field_main_cost_item_count self._m_has_field_main_cost_item_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_main_cost_item_count', None) class ConfigMusicInt32equalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CoopActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForceEnableShakeOffButton(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfComboConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ComboConfig(self._io, self, self._root)) class EnumOptionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OptionType, self.data.value) return getattr(self, '_m_value', None) class ConfigGraphicsVolatileSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_frame_rate_grade: self.frame_rate_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_render_resolution_grade: self.render_resolution_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shadow_quality_grade: self.shadow_quality_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_postprocess_effect_grade: self.postprocess_effect_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_particle_effect_grade: self.particle_effect_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_comprehensive_quality_grade: self.comprehensive_quality_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_v_sync: self.v_sync = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_anti_aliasing: self.anti_aliasing = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_volumetric_fog: self.volumetric_fog = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reflection: self.reflection = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_motion_blur: self.motion_blur = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bloom: self.bloom = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_crowd_density: self.crowd_density = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_obsolete_online_effect: self.obsolete_online_effect = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_screen_subsurface_scattering: self.screen_subsurface_scattering = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_online_effect: self.online_effect = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_particle_effect_grade(self): if hasattr(self, '_m_has_field_particle_effect_grade'): return self._m_has_field_particle_effect_grade self._m_has_field_particle_effect_grade = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_particle_effect_grade', None) @property def has_field_shadow_quality_grade(self): if hasattr(self, '_m_has_field_shadow_quality_grade'): return self._m_has_field_shadow_quality_grade self._m_has_field_shadow_quality_grade = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shadow_quality_grade', None) @property def has_field_postprocess_effect_grade(self): if hasattr(self, '_m_has_field_postprocess_effect_grade'): return self._m_has_field_postprocess_effect_grade self._m_has_field_postprocess_effect_grade = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_postprocess_effect_grade', None) @property def has_field_screen_subsurface_scattering(self): if hasattr(self, '_m_has_field_screen_subsurface_scattering'): return self._m_has_field_screen_subsurface_scattering self._m_has_field_screen_subsurface_scattering = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_screen_subsurface_scattering', None) @property def has_field_bloom(self): if hasattr(self, '_m_has_field_bloom'): return self._m_has_field_bloom self._m_has_field_bloom = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_bloom', None) @property def has_field_motion_blur(self): if hasattr(self, '_m_has_field_motion_blur'): return self._m_has_field_motion_blur self._m_has_field_motion_blur = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_motion_blur', None) @property def has_field_volumetric_fog(self): if hasattr(self, '_m_has_field_volumetric_fog'): return self._m_has_field_volumetric_fog self._m_has_field_volumetric_fog = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_volumetric_fog', None) @property def has_field_crowd_density(self): if hasattr(self, '_m_has_field_crowd_density'): return self._m_has_field_crowd_density self._m_has_field_crowd_density = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_crowd_density', None) @property def has_field_obsolete_online_effect(self): if hasattr(self, '_m_has_field_obsolete_online_effect'): return self._m_has_field_obsolete_online_effect self._m_has_field_obsolete_online_effect = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_obsolete_online_effect', None) @property def has_field_comprehensive_quality_grade(self): if hasattr(self, '_m_has_field_comprehensive_quality_grade'): return self._m_has_field_comprehensive_quality_grade self._m_has_field_comprehensive_quality_grade = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_comprehensive_quality_grade', None) @property def has_field_anti_aliasing(self): if hasattr(self, '_m_has_field_anti_aliasing'): return self._m_has_field_anti_aliasing self._m_has_field_anti_aliasing = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_anti_aliasing', None) @property def has_field_v_sync(self): if hasattr(self, '_m_has_field_v_sync'): return self._m_has_field_v_sync self._m_has_field_v_sync = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_v_sync', None) @property def has_field_online_effect(self): if hasattr(self, '_m_has_field_online_effect'): return self._m_has_field_online_effect self._m_has_field_online_effect = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_online_effect', None) @property def has_field_reflection(self): if hasattr(self, '_m_has_field_reflection'): return self._m_has_field_reflection self._m_has_field_reflection = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_reflection', None) @property def has_field_frame_rate_grade(self): if hasattr(self, '_m_has_field_frame_rate_grade'): return self._m_has_field_frame_rate_grade self._m_has_field_frame_rate_grade = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_frame_rate_grade', None) @property def has_field_render_resolution_grade(self): if hasattr(self, '_m_has_field_render_resolution_grade'): return self._m_has_field_render_resolution_grade self._m_has_field_render_resolution_grade = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_render_resolution_grade', None) class TriggerAttackEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_event: self.attack_event = Output.ConfigAttackEvent(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_is_reject: self.is_reject = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_is_reject(self): if hasattr(self, '_m_has_field_is_reject'): return self._m_has_field_is_reject self._m_has_field_is_reject = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_reject', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_entity_types', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_attack_event(self): if hasattr(self, '_m_has_field_attack_event'): return self._m_has_field_attack_event self._m_has_field_attack_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_event', None) class TutorialDetailExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMarkIconType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkIconType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigBattleFervorFactorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBattleFervorFactor(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeSConfigAiSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSurroundData(self._io, self, self._root) class SectrStreamLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sector_name_hash: self.sector_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_layer_name_hash: self.layer_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumSectrLayerType(self._io, self, self._root) if self.has_field_layer_full_name_hash: self.layer_full_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_sector_size: self.sector_size = Output.Vector(self._io, self, self._root) if self.has_field_layer_path_info: self.layer_path_info = Output.SectrCombineStreamPathInfo(self._io, self, self._root) if self.has_field_attach_layers: self.attach_layers = Output.ArrayOfSectrAttachStreamLayerLengthU(self._io, self, self._root) @property def has_field_layer_name_hash(self): if hasattr(self, '_m_has_field_layer_name_hash'): return self._m_has_field_layer_name_hash self._m_has_field_layer_name_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_layer_name_hash', None) @property def has_field_sector_name_hash(self): if hasattr(self, '_m_has_field_sector_name_hash'): return self._m_has_field_sector_name_hash self._m_has_field_sector_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sector_name_hash', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_attach_layers(self): if hasattr(self, '_m_has_field_attach_layers'): return self._m_has_field_attach_layers self._m_has_field_attach_layers = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_attach_layers', None) @property def has_field_layer_path_info(self): if hasattr(self, '_m_has_field_layer_path_info'): return self._m_has_field_layer_path_info self._m_has_field_layer_path_info = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_layer_path_info', None) @property def has_field_layer_full_name_hash(self): if hasattr(self, '_m_has_field_layer_full_name_hash'): return self._m_has_field_layer_full_name_hash self._m_has_field_layer_full_name_hash = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_layer_full_name_hash', None) @property def has_field_sector_size(self): if hasattr(self, '_m_has_field_sector_size'): return self._m_has_field_sector_size self._m_has_field_sector_size = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_sector_size', None) class EnvironmentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TurnDirection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_turn_mode: self.turn_mode = Output.EnumTurnMode(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_turn_mode(self): if hasattr(self, '_m_has_field_turn_mode'): return self._m_has_field_turn_mode self._m_has_field_turn_mode = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_turn_mode', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiRaycastCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min: self.min = self._io.read_f4le() if self.has_field_max: self.max = self._io.read_f4le() if self.has_field_raycast_type: self.raycast_type = Output.EnumRaycastType(self._io, self, self._root) @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max', None) @property def has_field_raycast_type(self): if hasattr(self, '_m_has_field_raycast_type'): return self._m_has_field_raycast_type self._m_has_field_raycast_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_raycast_type', None) class EnumStrengthenPointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StrengthenPointType, self.data.value) return getattr(self, '_m_value', None) class ResistClimateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_types: self.climate_types = Output.ArrayOfEnumJsonClimateTypeLengthU(self._io, self, self._root) if self.has_field_source: self.source = Output.EnumClimateSourceType(self._io, self, self._root) if self.has_field_trend: self.trend = Output.EnumClimateTrendType(self._io, self, self._root) if self.has_field_ratio: self.ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) @property def has_field_climate_types(self): if hasattr(self, '_m_has_field_climate_types'): return self._m_has_field_climate_types self._m_has_field_climate_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_types', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ratio', None) @property def has_field_trend(self): if hasattr(self, '_m_has_field_trend'): return self._m_has_field_trend self._m_has_field_trend = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trend', None) @property def has_field_source(self): if hasattr(self, '_m_has_field_source'): return self._m_has_field_source self._m_has_field_source = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_source', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictAuxTypesStringArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) class CcdTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessCardQualityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialStatisticsListExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class VehicleSkillDepotExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideSetOpenStateAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_open_state: self.open_state = Output.EnumGuideOpenStateType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_open_state', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ElementReactionShockMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_think_interval: self.think_interval = self._io.read_f4le() if self.has_field_camp_global_key: self.camp_global_key = AuxTypes.String(self._io, self, self._root) if self.has_field_attack_action: self.attack_action = Output.DispConfigAbilityAction(self._io, self, self._root) if self.has_field_conduct_action: self.conduct_action = Output.DispConfigAbilityAction(self._io, self, self._root) @property def has_field_camp_global_key(self): if hasattr(self, '_m_has_field_camp_global_key'): return self._m_has_field_camp_global_key self._m_has_field_camp_global_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camp_global_key', None) @property def has_field_conduct_action(self): if hasattr(self, '_m_has_field_conduct_action'): return self._m_has_field_conduct_action self._m_has_field_conduct_action = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_conduct_action', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_think_interval(self): if hasattr(self, '_m_has_field_think_interval'): return self._m_has_field_think_interval self._m_has_field_think_interval = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_think_interval', None) @property def has_field_attack_action(self): if hasattr(self, '_m_has_field_attack_action'): return self._m_has_field_attack_action self._m_has_field_attack_action = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attack_action', None) class TriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigSummonTagLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSummonTag(self._io, self, self._root)) class RogueDiaryBuffDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param: self.desc_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRogueDiaryBuffType(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumRogueDiaryBuffEffectType(self._io, self, self._root) @property def has_field_desc_param(self): if hasattr(self, '_m_has_field_desc_param'): return self._m_has_field_desc_param self._m_has_field_desc_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc_param', None) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quality', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class EnumDataEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DataEntityType, self.data.value) return getattr(self, '_m_value', None) class ModifySkiffPhysicsParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_angular_velocity_clamp: self.angular_velocity_clamp = self._io.read_f4le() if self.has_field_disable_min_speed: self.disable_min_speed = self._io.read_f4le() if self.has_field_angular_velocity_clamp_fade_time: self.angular_velocity_clamp_fade_time = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_disable_min_speed(self): if hasattr(self, '_m_has_field_disable_min_speed'): return self._m_has_field_disable_min_speed self._m_has_field_disable_min_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_disable_min_speed', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_angular_velocity_clamp(self): if hasattr(self, '_m_has_field_angular_velocity_clamp'): return self._m_has_field_angular_velocity_clamp self._m_has_field_angular_velocity_clamp = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angular_velocity_clamp', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_angular_velocity_clamp_fade_time(self): if hasattr(self, '_m_has_field_angular_velocity_clamp_fade_time'): return self._m_has_field_angular_velocity_clamp_fade_time self._m_has_field_angular_velocity_clamp_fade_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_angular_velocity_clamp_fade_time', None) class ConfigPlayPostEffectAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_asset_name: self.asset_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_remove: self.is_remove = self._io.read_u1() @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_is_remove(self): if hasattr(self, '_m_has_field_is_remove'): return self._m_has_field_is_remove self._m_has_field_is_remove = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_remove', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_asset_name(self): if hasattr(self, '_m_has_field_asset_name'): return self._m_has_field_asset_name self._m_has_field_asset_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_asset_name', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class KvpOfDictAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) class IndicatorOperatorComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DialogSteerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ItemLimitRefreshTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigTintFadeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tint_distance: self.tint_distance = self._io.read_f4le() if self.has_field_tint_size: self.tint_size = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_tint_distance(self): if hasattr(self, '_m_has_field_tint_distance'): return self._m_has_field_tint_distance self._m_has_field_tint_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tint_distance', None) @property def has_field_tint_size(self): if hasattr(self, '_m_has_field_tint_size'): return self._m_has_field_tint_size self._m_has_field_tint_size = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tint_size', None) class RandTaskLevelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CookMethodTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrPlatformStreamLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumSectrPlatformType(self._io, self, self._root) if self.has_field_layer_loader_path_hash: self.layer_loader_path_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_layer_loader_path_hash(self): if hasattr(self, '_m_has_field_layer_loader_path_hash'): return self._m_has_field_layer_loader_path_hash self._m_has_field_layer_loader_path_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_layer_loader_path_hash', None) class ConfigAiSpacialFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_range_radius_min: self.range_radius_min = self._io.read_f4le() if self.has_field_range_radius_max: self.range_radius_max = self._io.read_f4le() if self.has_field_rest_time_min: self.rest_time_min = self._io.read_f4le() if self.has_field_rest_time_max: self.rest_time_max = self._io.read_f4le() if self.has_field_facing_move_turn_interval: self.facing_move_turn_interval = self._io.read_f4le() if self.has_field_facing_move_min_avoidance_velecity: self.facing_move_min_avoidance_velecity = self._io.read_f4le() if self.has_field_obstacle_detect_range: self.obstacle_detect_range = self._io.read_f4le() if self.has_field_obstacle_up_range: self.obstacle_up_range = self._io.read_f4le() if self.has_field_obstacle_max_angle: self.obstacle_max_angle = self._io.read_f4le() if self.has_field_spacial_facing_move_probability: self.spacial_facing_move_probability = Output.ConfigAiSpacialFacingMoveProbability(self._io, self, self._root) if self.has_field_can_start_range_by_raycast: self.can_start_range_by_raycast = Output.ArrayOfConfigAiRaycastConditionLengthU(self._io, self, self._root) @property def has_field_obstacle_detect_range(self): if hasattr(self, '_m_has_field_obstacle_detect_range'): return self._m_has_field_obstacle_detect_range self._m_has_field_obstacle_detect_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_obstacle_detect_range', None) @property def has_field_obstacle_up_range(self): if hasattr(self, '_m_has_field_obstacle_up_range'): return self._m_has_field_obstacle_up_range self._m_has_field_obstacle_up_range = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_obstacle_up_range', None) @property def has_field_range_radius_min(self): if hasattr(self, '_m_has_field_range_radius_min'): return self._m_has_field_range_radius_min self._m_has_field_range_radius_min = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_range_radius_min', None) @property def has_field_facing_move_min_avoidance_velecity(self): if hasattr(self, '_m_has_field_facing_move_min_avoidance_velecity'): return self._m_has_field_facing_move_min_avoidance_velecity self._m_has_field_facing_move_min_avoidance_velecity = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_facing_move_min_avoidance_velecity', None) @property def has_field_rest_time_max(self): if hasattr(self, '_m_has_field_rest_time_max'): return self._m_has_field_rest_time_max self._m_has_field_rest_time_max = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_rest_time_max', None) @property def has_field_range_radius_max(self): if hasattr(self, '_m_has_field_range_radius_max'): return self._m_has_field_range_radius_max self._m_has_field_range_radius_max = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_range_radius_max', None) @property def has_field_facing_move_turn_interval(self): if hasattr(self, '_m_has_field_facing_move_turn_interval'): return self._m_has_field_facing_move_turn_interval self._m_has_field_facing_move_turn_interval = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_facing_move_turn_interval', None) @property def has_field_rest_time_min(self): if hasattr(self, '_m_has_field_rest_time_min'): return self._m_has_field_rest_time_min self._m_has_field_rest_time_min = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_rest_time_min', None) @property def has_field_can_start_range_by_raycast(self): if hasattr(self, '_m_has_field_can_start_range_by_raycast'): return self._m_has_field_can_start_range_by_raycast self._m_has_field_can_start_range_by_raycast = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_can_start_range_by_raycast', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_obstacle_max_angle(self): if hasattr(self, '_m_has_field_obstacle_max_angle'): return self._m_has_field_obstacle_max_angle self._m_has_field_obstacle_max_angle = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_obstacle_max_angle', None) @property def has_field_spacial_facing_move_probability(self): if hasattr(self, '_m_has_field_spacial_facing_move_probability'): return self._m_has_field_spacial_facing_move_probability self._m_has_field_spacial_facing_move_probability = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_spacial_facing_move_probability', None) class ArrayOfConfigTileElementLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigTileElement(self._io, self, self._root)) class NewActivityWatcherConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringDispConfigLcBaseIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigLcBaseIntee(self._io, self, self._root)) class FieldEntityCountChangeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_force_trigger_when_change_authority: self.force_trigger_when_change_authority = self._io.read_u1() if self.has_field_target_predicates: self.target_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_on_field_enter: self.on_field_enter = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_field_exit: self.on_field_exit = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_field_enter(self): if hasattr(self, '_m_has_field_on_field_enter'): return self._m_has_field_on_field_enter self._m_has_field_on_field_enter = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_field_enter', None) @property def has_field_force_trigger_when_change_authority(self): if hasattr(self, '_m_has_field_force_trigger_when_change_authority'): return self._m_has_field_force_trigger_when_change_authority self._m_has_field_force_trigger_when_change_authority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_force_trigger_when_change_authority', None) @property def has_field_target_predicates(self): if hasattr(self, '_m_has_field_target_predicates'): return self._m_has_field_target_predicates self._m_has_field_target_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_predicates', None) @property def has_field_on_field_exit(self): if hasattr(self, '_m_has_field_on_field_exit'): return self._m_has_field_on_field_exit self._m_has_field_on_field_exit = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_field_exit', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumMonsterRarityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonsterRarityType, self.data.value) return getattr(self, '_m_value', None) class ModifierEventRefJump(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_event_jump_dict: self.event_jump_dict = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_event_jump_dict(self): if hasattr(self, '_m_has_field_event_jump_dict'): return self._m_has_field_event_jump_dict self._m_has_field_event_jump_dict = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_jump_dict', None) class FettersExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChangeEnviroWeather(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_climate_type: self.climate_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trans_duration: self.trans_duration = self._io.read_f4le() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_trans_duration(self): if hasattr(self, '_m_has_field_trans_duration'): return self._m_has_field_trans_duration self._m_has_field_trans_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trans_duration', None) class EnumCoopCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopCondType, self.data.value) return getattr(self, '_m_value', None) class ContextCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BuoyantCombatLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_rule: self.level_rule = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_rule_brief: self.level_rule_brief = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_score: self.watcher_score = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_icon_position: self.icon_position = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_level_rule(self): if hasattr(self, '_m_has_field_level_rule'): return self._m_has_field_level_rule self._m_has_field_level_rule = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level_rule', None) @property def has_field_icon_position(self): if hasattr(self, '_m_has_field_icon_position'): return self._m_has_field_icon_position self._m_has_field_icon_position = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_icon_position', None) @property def has_field_watcher_score(self): if hasattr(self, '_m_has_field_watcher_score'): return self._m_has_field_watcher_score self._m_has_field_watcher_score = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_watcher_score', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_level_rule_brief(self): if hasattr(self, '_m_has_field_level_rule_brief'): return self._m_has_field_level_rule_brief self._m_has_field_level_rule_brief = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_level_rule_brief', None) class EnumSumoDifficultyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SumoDifficultyType, self.data.value) return getattr(self, '_m_value', None) class RadarHintTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarFettersLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_fetter_level: self.fetter_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_exp: self.need_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_fetter_level(self): if hasattr(self, '_m_has_field_fetter_level'): return self._m_has_field_fetter_level self._m_has_field_fetter_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_fetter_level', None) @property def has_field_need_exp(self): if hasattr(self, '_m_has_field_need_exp'): return self._m_has_field_need_exp self._m_has_field_need_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_need_exp', None) class OverrideStickElemUiMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_eff_name: self.eff_name = AuxTypes.String(self._io, self, self._root) @property def has_field_eff_name(self): if hasattr(self, '_m_has_field_eff_name'): return self._m_has_field_eff_name self._m_has_field_eff_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_eff_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class PhotographPoseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_character_id: self.character_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pose_id: self.pose_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_character_id(self): if hasattr(self, '_m_has_field_character_id'): return self._m_has_field_character_id self._m_has_field_character_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_character_id', None) @property def has_field_pose_id(self): if hasattr(self, '_m_has_field_pose_id'): return self._m_has_field_pose_id self._m_has_field_pose_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pose_id', None) class GadgetChainExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_chain_id: self.chain_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_init_level: self.init_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_level: self.max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_list: self.buff_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_chain_id(self): if hasattr(self, '_m_has_field_chain_id'): return self._m_has_field_chain_id self._m_has_field_chain_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_chain_id', None) @property def has_field_init_level(self): if hasattr(self, '_m_has_field_init_level'): return self._m_has_field_init_level self._m_has_field_init_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_init_level', None) @property def has_field_max_level(self): if hasattr(self, '_m_has_field_max_level'): return self._m_has_field_max_level self._m_has_field_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_level', None) @property def has_field_buff_list(self): if hasattr(self, '_m_has_field_buff_list'): return self._m_has_field_buff_list self._m_has_field_buff_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_buff_list', None) class DictOfAuxTypesStringAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAuxTypesVlqBase128LeS(self._io, self, self._root)) class NewActivitySaleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigActionPointSelectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMoveSyncInterval(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_lod0: self.lod0 = Output.ConfigSpecificFloatValue(self._io, self, self._root) if self.has_field_lod1: self.lod1 = Output.ConfigSpecificFloatValue(self._io, self, self._root) if self.has_field_lod2: self.lod2 = Output.ConfigSpecificFloatValue(self._io, self, self._root) @property def has_field_lod0(self): if hasattr(self, '_m_has_field_lod0'): return self._m_has_field_lod0 self._m_has_field_lod0 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lod0', None) @property def has_field_lod1(self): if hasattr(self, '_m_has_field_lod1'): return self._m_has_field_lod1 self._m_has_field_lod1 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lod1', None) @property def has_field_lod2(self): if hasattr(self, '_m_has_field_lod2'): return self._m_has_field_lod2 self._m_has_field_lod2 = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_lod2', None) class ChestShowMomentComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NightCrowArgumentExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_argument_id: self.argument_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_state_list: self.gadget_state_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pos_offset: self.pos_offset = AuxTypes.String(self._io, self, self._root) if self.has_field_rotation: self.rotation = AuxTypes.String(self._io, self, self._root) if self.has_field_position_list: self.position_list = AuxTypes.String(self._io, self, self._root) if self.has_field_limit_position_list: self.limit_position_list = AuxTypes.String(self._io, self, self._root) if self.has_field_limit_center_position: self.limit_center_position = AuxTypes.String(self._io, self, self._root) if self.has_field_nipjpojheok: self.nipjpojheok = AuxTypes.String(self._io, self, self._root) if self.has_field_dpcccgdcekj: self.dpcccgdcekj = AuxTypes.String(self._io, self, self._root) if self.has_field_fov: self.fov = AuxTypes.String(self._io, self, self._root) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_rotation', None) @property def has_field_position_list(self): if hasattr(self, '_m_has_field_position_list'): return self._m_has_field_position_list self._m_has_field_position_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_position_list', None) @property def has_field_argument_id(self): if hasattr(self, '_m_has_field_argument_id'): return self._m_has_field_argument_id self._m_has_field_argument_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_argument_id', None) @property def has_field_limit_position_list(self): if hasattr(self, '_m_has_field_limit_position_list'): return self._m_has_field_limit_position_list self._m_has_field_limit_position_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_limit_position_list', None) @property def has_field_limit_center_position(self): if hasattr(self, '_m_has_field_limit_center_position'): return self._m_has_field_limit_center_position self._m_has_field_limit_center_position = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_limit_center_position', None) @property def has_field_pos_offset(self): if hasattr(self, '_m_has_field_pos_offset'): return self._m_has_field_pos_offset self._m_has_field_pos_offset = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pos_offset', None) @property def has_field_nipjpojheok(self): if hasattr(self, '_m_has_field_nipjpojheok'): return self._m_has_field_nipjpojheok self._m_has_field_nipjpojheok = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_nipjpojheok', None) @property def has_field_gadget_state_list(self): if hasattr(self, '_m_has_field_gadget_state_list'): return self._m_has_field_gadget_state_list self._m_has_field_gadget_state_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_state_list', None) @property def has_field_fov(self): if hasattr(self, '_m_has_field_fov'): return self._m_has_field_fov self._m_has_field_fov = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_fov', None) @property def has_field_dpcccgdcekj(self): if hasattr(self, '_m_has_field_dpcccgdcekj'): return self._m_has_field_dpcccgdcekj self._m_has_field_dpcccgdcekj = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_dpcccgdcekj', None) class RegionSearchCondExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_name: self.search_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_desc: self.search_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_map_desc: self.search_map_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic_type: self.logic_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfRegionSearchCondLengthS(self._io, self, self._root) if self.has_field_region_list: self.region_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_progress: self.total_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_id: self.reminder_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_reminder_id(self): if hasattr(self, '_m_has_field_reminder_id'): return self._m_has_field_reminder_id self._m_has_field_reminder_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_reminder_id', None) @property def has_field_region_list(self): if hasattr(self, '_m_has_field_region_list'): return self._m_has_field_region_list self._m_has_field_region_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_region_list', None) @property def has_field_search_desc(self): if hasattr(self, '_m_has_field_search_desc'): return self._m_has_field_search_desc self._m_has_field_search_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_search_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_total_progress(self): if hasattr(self, '_m_has_field_total_progress'): return self._m_has_field_total_progress self._m_has_field_total_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_total_progress', None) @property def has_field_search_map_desc(self): if hasattr(self, '_m_has_field_search_map_desc'): return self._m_has_field_search_map_desc self._m_has_field_search_map_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_search_map_desc', None) @property def has_field_logic_type(self): if hasattr(self, '_m_has_field_logic_type'): return self._m_has_field_logic_type self._m_has_field_logic_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_logic_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_search_name(self): if hasattr(self, '_m_has_field_search_name'): return self._m_has_field_search_name self._m_has_field_search_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_search_name', None) class ManualTextMapConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_text_map_id: self.text_map_id = AuxTypes.String(self._io, self, self._root) if self.has_field_text_map_content: self.text_map_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param_types: self.param_types = Output.ArrayOfEnumTextParamTypeLengthS(self._io, self, self._root) @property def has_field_text_map_id(self): if hasattr(self, '_m_has_field_text_map_id'): return self._m_has_field_text_map_id self._m_has_field_text_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_text_map_id', None) @property def has_field_text_map_content(self): if hasattr(self, '_m_has_field_text_map_content'): return self._m_has_field_text_map_content self._m_has_field_text_map_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_text_map_content', None) @property def has_field_param_types(self): if hasattr(self, '_m_has_field_param_types'): return self._m_has_field_param_types self._m_has_field_param_types = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param_types', None) class ArrayOfDispConfigAbilityMixinLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigAbilityMixin(self._io, self, self._root)) class MarkVisibleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMistTrialClientSyncType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MistTrialClientSyncType, self.data.value) return getattr(self, '_m_value', None) class EnumConfigKeyCode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigKeyCode, self.data.value) return getattr(self, '_m_value', None) class ConfigPlatformPreloadMapping(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_editor: self.editor = Output.DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) if self.has_field_win: self.win = Output.DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) if self.has_field_android: self.android = Output.DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) if self.has_field_ps4: self.ps4 = Output.DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) if self.has_field_ios: self.ios = Output.DictOfEnumConfigPreloadTypeArrayOfEnumConfigPreloadTypeLengthU(self._io, self, self._root) @property def has_field_editor(self): if hasattr(self, '_m_has_field_editor'): return self._m_has_field_editor self._m_has_field_editor = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_editor', None) @property def has_field_android(self): if hasattr(self, '_m_has_field_android'): return self._m_has_field_android self._m_has_field_android = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_android', None) @property def has_field_win(self): if hasattr(self, '_m_has_field_win'): return self._m_has_field_win self._m_has_field_win = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_win', None) @property def has_field_ios(self): if hasattr(self, '_m_has_field_ios'): return self._m_has_field_ios self._m_has_field_ios = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ios', None) @property def has_field_ps4(self): if hasattr(self, '_m_has_field_ps4'): return self._m_has_field_ps4 self._m_has_field_ps4 = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ps4', None) class DictOfAuxTypesVlqBase128LeSConfigAiFollowServerRouteData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFollowServerRouteData(self._io, self, self._root)) class AvatarPromoteExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalHit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_hit_vx: self.min_hit_vx = self._io.read_f4le() if self.has_field_max_hit_vx: self.max_hit_vx = self._io.read_f4le() if self.has_field_min_hit_vy: self.min_hit_vy = self._io.read_f4le() if self.has_field_max_hit_vy: self.max_hit_vy = self._io.read_f4le() if self.has_field_gravity: self.gravity = self._io.read_f4le() if self.has_field_hit_retreat_friction: self.hit_retreat_friction = self._io.read_f4le() if self.has_field_air_friction_x: self.air_friction_x = self._io.read_f4le() if self.has_field_air_friction_y: self.air_friction_y = self._io.read_f4le() if self.has_field_die_retreat_ratio: self.die_retreat_ratio = self._io.read_f4le() if self.has_field_die_retreat_light_ratio: self.die_retreat_light_ratio = self._io.read_f4le() if self.has_field_die_retreat_heavy_ratio: self.die_retreat_heavy_ratio = self._io.read_f4le() if self.has_field_die_retreat_add: self.die_retreat_add = self._io.read_f4le() if self.has_field_die_retreat_heavy_add: self.die_retreat_heavy_add = self._io.read_f4le() if self.has_field_die_retreat_air_x_add: self.die_retreat_air_x_add = self._io.read_f4le() if self.has_field_die_retreat_air_y_add: self.die_retreat_air_y_add = self._io.read_f4le() @property def has_field_hit_retreat_friction(self): if hasattr(self, '_m_has_field_hit_retreat_friction'): return self._m_has_field_hit_retreat_friction self._m_has_field_hit_retreat_friction = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_hit_retreat_friction', None) @property def has_field_air_friction_y(self): if hasattr(self, '_m_has_field_air_friction_y'): return self._m_has_field_air_friction_y self._m_has_field_air_friction_y = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_air_friction_y', None) @property def has_field_air_friction_x(self): if hasattr(self, '_m_has_field_air_friction_x'): return self._m_has_field_air_friction_x self._m_has_field_air_friction_x = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_air_friction_x', None) @property def has_field_gravity(self): if hasattr(self, '_m_has_field_gravity'): return self._m_has_field_gravity self._m_has_field_gravity = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_gravity', None) @property def has_field_die_retreat_add(self): if hasattr(self, '_m_has_field_die_retreat_add'): return self._m_has_field_die_retreat_add self._m_has_field_die_retreat_add = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_die_retreat_add', None) @property def has_field_die_retreat_heavy_ratio(self): if hasattr(self, '_m_has_field_die_retreat_heavy_ratio'): return self._m_has_field_die_retreat_heavy_ratio self._m_has_field_die_retreat_heavy_ratio = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_die_retreat_heavy_ratio', None) @property def has_field_die_retreat_air_x_add(self): if hasattr(self, '_m_has_field_die_retreat_air_x_add'): return self._m_has_field_die_retreat_air_x_add self._m_has_field_die_retreat_air_x_add = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_die_retreat_air_x_add', None) @property def has_field_max_hit_vy(self): if hasattr(self, '_m_has_field_max_hit_vy'): return self._m_has_field_max_hit_vy self._m_has_field_max_hit_vy = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_max_hit_vy', None) @property def has_field_min_hit_vx(self): if hasattr(self, '_m_has_field_min_hit_vx'): return self._m_has_field_min_hit_vx self._m_has_field_min_hit_vx = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_min_hit_vx', None) @property def has_field_die_retreat_light_ratio(self): if hasattr(self, '_m_has_field_die_retreat_light_ratio'): return self._m_has_field_die_retreat_light_ratio self._m_has_field_die_retreat_light_ratio = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_die_retreat_light_ratio', None) @property def has_field_max_hit_vx(self): if hasattr(self, '_m_has_field_max_hit_vx'): return self._m_has_field_max_hit_vx self._m_has_field_max_hit_vx = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_max_hit_vx', None) @property def has_field_die_retreat_air_y_add(self): if hasattr(self, '_m_has_field_die_retreat_air_y_add'): return self._m_has_field_die_retreat_air_y_add self._m_has_field_die_retreat_air_y_add = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_die_retreat_air_y_add', None) @property def has_field_die_retreat_ratio(self): if hasattr(self, '_m_has_field_die_retreat_ratio'): return self._m_has_field_die_retreat_ratio self._m_has_field_die_retreat_ratio = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_die_retreat_ratio', None) @property def has_field_min_hit_vy(self): if hasattr(self, '_m_has_field_min_hit_vy'): return self._m_has_field_min_hit_vy self._m_has_field_min_hit_vy = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_min_hit_vy', None) @property def has_field_die_retreat_heavy_add(self): if hasattr(self, '_m_has_field_die_retreat_heavy_add'): return self._m_has_field_die_retreat_heavy_add self._m_has_field_die_retreat_heavy_add = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_die_retreat_heavy_add', None) class EnumAudioScope(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AudioScope, self.data.value) return getattr(self, '_m_value', None) class BartenderTaskOrderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDamageAttacker(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DamageAttacker, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigPlatformUiAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPlatformUiAction(self._io, self, self._root)) class ModifyVehicleSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_delta: self.cd_delta = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cd_ratio: self.cd_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_cd_delta(self): if hasattr(self, '_m_has_field_cd_delta'): return self._m_has_field_cd_delta self._m_has_field_cd_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_delta', None) class BuffStackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BonusActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_bonus_activity_id: self.bonus_activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_list: self.cond_list = Output.ArrayOfSignInCondConfigLengthS(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_item_list: self.reward_item_list = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_reward_item_list(self): if hasattr(self, '_m_has_field_reward_item_list'): return self._m_has_field_reward_item_list self._m_has_field_reward_item_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_item_list', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_bonus_activity_id(self): if hasattr(self, '_m_has_field_bonus_activity_id'): return self._m_has_field_bonus_activity_id self._m_has_field_bonus_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_bonus_activity_id', None) @property def has_field_cond_list(self): if hasattr(self, '_m_has_field_cond_list'): return self._m_has_field_cond_list self._m_has_field_cond_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ArrayOfRandomQuestFilterConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandomQuestFilterConfig(self._io, self, self._root)) class ConfigModel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_mat_linear_changed_by_distance: self.mat_linear_changed_by_distance = Output.ArrayOfConfigMatLinearChangedByDistanceLengthU(self._io, self, self._root) if self.has_field_born_effect: self.born_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_effect: self.attach_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_ignore_dist_check_when_attach_effect: self.ignore_dist_check_when_attach_effect = self._io.read_u1() if self.has_field_can_bake_mesh: self.can_bake_mesh = self._io.read_u1() if self.has_field_set_per_object_shadow_group_id: self.set_per_object_shadow_group_id = self._io.read_u1() if self.has_field_has_character_renderering: self.has_character_renderering = self._io.read_u1() @property def has_field_has_character_renderering(self): if hasattr(self, '_m_has_field_has_character_renderering'): return self._m_has_field_has_character_renderering self._m_has_field_has_character_renderering = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_has_character_renderering', None) @property def has_field_ignore_dist_check_when_attach_effect(self): if hasattr(self, '_m_has_field_ignore_dist_check_when_attach_effect'): return self._m_has_field_ignore_dist_check_when_attach_effect self._m_has_field_ignore_dist_check_when_attach_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ignore_dist_check_when_attach_effect', None) @property def has_field_attach_effect(self): if hasattr(self, '_m_has_field_attach_effect'): return self._m_has_field_attach_effect self._m_has_field_attach_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attach_effect', None) @property def has_field_set_per_object_shadow_group_id(self): if hasattr(self, '_m_has_field_set_per_object_shadow_group_id'): return self._m_has_field_set_per_object_shadow_group_id self._m_has_field_set_per_object_shadow_group_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_set_per_object_shadow_group_id', None) @property def has_field_can_bake_mesh(self): if hasattr(self, '_m_has_field_can_bake_mesh'): return self._m_has_field_can_bake_mesh self._m_has_field_can_bake_mesh = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_can_bake_mesh', None) @property def has_field_mat_linear_changed_by_distance(self): if hasattr(self, '_m_has_field_mat_linear_changed_by_distance'): return self._m_has_field_mat_linear_changed_by_distance self._m_has_field_mat_linear_changed_by_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mat_linear_changed_by_distance', None) @property def has_field_born_effect(self): if hasattr(self, '_m_has_field_born_effect'): return self._m_has_field_born_effect self._m_has_field_born_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born_effect', None) class ConfigSpatialAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_list: self.room_list = Output.ArrayOfConfigSpatialRoomLengthU(self._io, self, self._root) if self.has_field_portal_list: self.portal_list = Output.ArrayOfConfigSpatialPortalLengthU(self._io, self, self._root) if self.has_field_global_room: self.global_room = AuxTypes.String(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_room_list(self): if hasattr(self, '_m_has_field_room_list'): return self._m_has_field_room_list self._m_has_field_room_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_room_list', None) @property def has_field_portal_list(self): if hasattr(self, '_m_has_field_portal_list'): return self._m_has_field_portal_list self._m_has_field_portal_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_portal_list', None) @property def has_field_global_room(self): if hasattr(self, '_m_has_field_global_room'): return self._m_has_field_global_room self._m_has_field_global_room = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_global_room', None) class ChannellerSlabPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_stay_time: self.activity_stay_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id: self.unlock_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_slab_quest_id: self.slab_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_player_level: self.unlock_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_reward_gadget_id: self.level_reward_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_mask_avatar_reward: self.is_mask_avatar_reward = self._io.read_u1() if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_mask_avatar_reward(self): if hasattr(self, '_m_has_field_is_mask_avatar_reward'): return self._m_has_field_is_mask_avatar_reward self._m_has_field_is_mask_avatar_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_mask_avatar_reward', None) @property def has_field_unlock_quest_id(self): if hasattr(self, '_m_has_field_unlock_quest_id'): return self._m_has_field_unlock_quest_id self._m_has_field_unlock_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_quest_id', None) @property def has_field_unlock_player_level(self): if hasattr(self, '_m_has_field_unlock_player_level'): return self._m_has_field_unlock_player_level self._m_has_field_unlock_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_unlock_player_level', None) @property def has_field_activity_stay_time(self): if hasattr(self, '_m_has_field_activity_stay_time'): return self._m_has_field_activity_stay_time self._m_has_field_activity_stay_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_stay_time', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_level_reward_gadget_id(self): if hasattr(self, '_m_has_field_level_reward_gadget_id'): return self._m_has_field_level_reward_gadget_id self._m_has_field_level_reward_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_level_reward_gadget_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_slab_quest_id(self): if hasattr(self, '_m_has_field_slab_quest_id'): return self._m_has_field_slab_quest_id self._m_has_field_slab_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_slab_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigMassiveEntityElement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_element_durability: self.element_durability = self._io.read_f4le() if self.has_field_is_element_durability_mutable: self.is_element_durability_mutable = self._io.read_u1() @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_type', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_element_durability(self): if hasattr(self, '_m_has_field_element_durability'): return self._m_has_field_element_durability self._m_has_field_element_durability = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_element_durability', None) @property def has_field_is_element_durability_mutable(self): if hasattr(self, '_m_has_field_is_element_durability_mutable'): return self._m_has_field_is_element_durability_mutable self._m_has_field_is_element_durability_mutable = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_element_durability_mutable', None) class NewActivityCondExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCoopBaseNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_coop_node_id: self.coop_node_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_node_type: self.coop_node_type = Output.EnumCoopNodeType(self._io, self, self._root) if self.has_field_next_node_array: self.next_node_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_coop_node_id(self): if hasattr(self, '_m_has_field_coop_node_id'): return self._m_has_field_coop_node_id self._m_has_field_coop_node_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_coop_node_id', None) @property def has_field_coop_node_type(self): if hasattr(self, '_m_has_field_coop_node_type'): return self._m_has_field_coop_node_type self._m_has_field_coop_node_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_coop_node_type', None) @property def has_field_next_node_array(self): if hasattr(self, '_m_has_field_next_node_array'): return self._m_has_field_next_node_array self._m_has_field_next_node_array = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_node_array', None) class RefreshUiCombatBarLayout(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigRenderResolutionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRenderResolution(self._io, self, self._root)) class ServerMonsterLog(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param_list', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SettleUiTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMoveStateMixinType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoveStateMixinType, self.data.value) return getattr(self, '_m_value', None) class ConfigGlobalLockTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_lock_weight_out_camera_param: self.lock_weight_out_camera_param = self._io.read_f4le() if self.has_field_lock_weight_relock_param: self.lock_weight_relock_param = self._io.read_f4le() if self.has_field_clear_lock_target_out_combat: self.clear_lock_target_out_combat = self._io.read_f4le() if self.has_field_clear_lock_target_in_combat: self.clear_lock_target_in_combat = self._io.read_f4le() if self.has_field_force_lock_target_in_combat: self.force_lock_target_in_combat = self._io.read_f4le() @property def has_field_lock_weight_relock_param(self): if hasattr(self, '_m_has_field_lock_weight_relock_param'): return self._m_has_field_lock_weight_relock_param self._m_has_field_lock_weight_relock_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lock_weight_relock_param', None) @property def has_field_clear_lock_target_in_combat(self): if hasattr(self, '_m_has_field_clear_lock_target_in_combat'): return self._m_has_field_clear_lock_target_in_combat self._m_has_field_clear_lock_target_in_combat = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_clear_lock_target_in_combat', None) @property def has_field_lock_weight_out_camera_param(self): if hasattr(self, '_m_has_field_lock_weight_out_camera_param'): return self._m_has_field_lock_weight_out_camera_param self._m_has_field_lock_weight_out_camera_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lock_weight_out_camera_param', None) @property def has_field_clear_lock_target_out_combat(self): if hasattr(self, '_m_has_field_clear_lock_target_out_combat'): return self._m_has_field_clear_lock_target_out_combat self._m_has_field_clear_lock_target_out_combat = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_clear_lock_target_out_combat', None) @property def has_field_force_lock_target_in_combat(self): if hasattr(self, '_m_has_field_force_lock_target_in_combat'): return self._m_has_field_force_lock_target_in_combat self._m_has_field_force_lock_target_in_combat = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_force_lock_target_in_combat', None) class TalkExecTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHitPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_on_hit_effect_name: self.on_hit_effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_level: self.hit_level = Output.EnumHitLevel(self._io, self, self._root) if self.has_field_hit_impulse_x: self.hit_impulse_x = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_hit_impulse_y: self.hit_impulse_y = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_hit_impulse_type: self.hit_impulse_type = AuxTypes.String(self._io, self, self._root) if self.has_field_override_hit_impulse: self.override_hit_impulse = Output.ConfigHitImpulse(self._io, self, self._root) if self.has_field_retreat_type: self.retreat_type = Output.EnumRetreatType(self._io, self, self._root) if self.has_field_hit_halt_time: self.hit_halt_time = self._io.read_f4le() if self.has_field_hit_halt_time_scale: self.hit_halt_time_scale = self._io.read_f4le() if self.has_field_can_be_defence_halt: self.can_be_defence_halt = self._io.read_u1() if self.has_field_mute_hit_text: self.mute_hit_text = self._io.read_u1() if self.has_field_recurring: self.recurring = self._io.read_u1() if self.has_field_force_retreat: self.force_retreat = self._io.read_u1() @property def has_field_mute_hit_text(self): if hasattr(self, '_m_has_field_mute_hit_text'): return self._m_has_field_mute_hit_text self._m_has_field_mute_hit_text = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_mute_hit_text', None) @property def has_field_retreat_type(self): if hasattr(self, '_m_has_field_retreat_type'): return self._m_has_field_retreat_type self._m_has_field_retreat_type = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_retreat_type', None) @property def has_field_hit_impulse_type(self): if hasattr(self, '_m_has_field_hit_impulse_type'): return self._m_has_field_hit_impulse_type self._m_has_field_hit_impulse_type = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_hit_impulse_type', None) @property def has_field_hit_halt_time(self): if hasattr(self, '_m_has_field_hit_halt_time'): return self._m_has_field_hit_halt_time self._m_has_field_hit_halt_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_hit_halt_time', None) @property def has_field_force_retreat(self): if hasattr(self, '_m_has_field_force_retreat'): return self._m_has_field_force_retreat self._m_has_field_force_retreat = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_force_retreat', None) @property def has_field_on_hit_effect_name(self): if hasattr(self, '_m_has_field_on_hit_effect_name'): return self._m_has_field_on_hit_effect_name self._m_has_field_on_hit_effect_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_on_hit_effect_name', None) @property def has_field_override_hit_impulse(self): if hasattr(self, '_m_has_field_override_hit_impulse'): return self._m_has_field_override_hit_impulse self._m_has_field_override_hit_impulse = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_override_hit_impulse', None) @property def has_field_hit_level(self): if hasattr(self, '_m_has_field_hit_level'): return self._m_has_field_hit_level self._m_has_field_hit_level = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_hit_level', None) @property def has_field_hit_impulse_x(self): if hasattr(self, '_m_has_field_hit_impulse_x'): return self._m_has_field_hit_impulse_x self._m_has_field_hit_impulse_x = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_hit_impulse_x', None) @property def has_field_recurring(self): if hasattr(self, '_m_has_field_recurring'): return self._m_has_field_recurring self._m_has_field_recurring = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_recurring', None) @property def has_field_hit_impulse_y(self): if hasattr(self, '_m_has_field_hit_impulse_y'): return self._m_has_field_hit_impulse_y self._m_has_field_hit_impulse_y = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_hit_impulse_y', None) @property def has_field_hit_halt_time_scale(self): if hasattr(self, '_m_has_field_hit_halt_time_scale'): return self._m_has_field_hit_halt_time_scale self._m_has_field_hit_halt_time_scale = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_hit_halt_time_scale', None) @property def has_field_can_be_defence_halt(self): if hasattr(self, '_m_has_field_can_be_defence_halt'): return self._m_has_field_can_be_defence_halt self._m_has_field_can_be_defence_halt = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_can_be_defence_halt', None) class IrodoriFlowerThemeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_theme_id: self.theme_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_title: self.theme_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_desc: self.theme_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_target: self.theme_target = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_picture_hash: self.target_picture_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_picture_hash: self.target_picture_hash_pre = self._io.read_s1() if self.has_field_time_limit: self.time_limit = self._io.read_f4le() if self.has_field_flower_id: self.flower_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stage_unlock_cond_id: self.stage_unlock_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_unlock_cond_id: self.theme_unlock_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_theme_unlock_cond_id(self): if hasattr(self, '_m_has_field_theme_unlock_cond_id'): return self._m_has_field_theme_unlock_cond_id self._m_has_field_theme_unlock_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_theme_unlock_cond_id', None) @property def has_field_time_limit(self): if hasattr(self, '_m_has_field_time_limit'): return self._m_has_field_time_limit self._m_has_field_time_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_time_limit', None) @property def has_field_theme_desc(self): if hasattr(self, '_m_has_field_theme_desc'): return self._m_has_field_theme_desc self._m_has_field_theme_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_theme_desc', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_target_picture_hash(self): if hasattr(self, '_m_has_field_target_picture_hash'): return self._m_has_field_target_picture_hash self._m_has_field_target_picture_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_target_picture_hash', None) @property def has_field_theme_target(self): if hasattr(self, '_m_has_field_theme_target'): return self._m_has_field_theme_target self._m_has_field_theme_target = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_theme_target', None) @property def has_field_flower_id(self): if hasattr(self, '_m_has_field_flower_id'): return self._m_has_field_flower_id self._m_has_field_flower_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_flower_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_theme_title(self): if hasattr(self, '_m_has_field_theme_title'): return self._m_has_field_theme_title self._m_has_field_theme_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_theme_title', None) @property def has_field_theme_id(self): if hasattr(self, '_m_has_field_theme_id'): return self._m_has_field_theme_id self._m_has_field_theme_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_theme_id', None) @property def has_field_stage_unlock_cond_id(self): if hasattr(self, '_m_has_field_stage_unlock_cond_id'): return self._m_has_field_stage_unlock_cond_id self._m_has_field_stage_unlock_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_stage_unlock_cond_id', None) class EnumHideAndSeekSkillSubCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HideAndSeekSkillSubCategory, self.data.value) return getattr(self, '_m_value', None) class DispConfigPerfItemOptionArrayInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigPerfGradeItemOptionArrayInfo(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigPerfCombineItemOptionArrayInfo(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigPerfNumberItemOptionArrayInfo(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigPerfStringKeyItemOptionArrayInfo(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigPerfBoolItemOptionArrayInfo(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigPerfNumberArrayItemOptionArrayInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class OnLocalAvatarAddedShieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shield_type_list: self.shield_type_list = Output.ArrayOfEnumHasShieldTypeLengthU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_shield_type_list(self): if hasattr(self, '_m_has_field_shield_type_list'): return self._m_has_field_shield_type_list self._m_has_field_shield_type_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shield_type_list', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfConfigHomeFurnitureLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeFurniture(self._io, self, self._root)) class WidgetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_redpoint: self.show_redpoint = self._io.read_u1() if self.has_field_customize_desc: self.customize_desc = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_show_redpoint(self): if hasattr(self, '_m_has_field_show_redpoint'): return self._m_has_field_show_redpoint self._m_has_field_show_redpoint = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_show_redpoint', None) @property def has_field_customize_desc(self): if hasattr(self, '_m_has_field_customize_desc'): return self._m_has_field_customize_desc self._m_has_field_customize_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_customize_desc', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) class AbilityGroupSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BaseDropIndexConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_level: self.min_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_tag: self.drop_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_count: self.drop_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_min_level(self): if hasattr(self, '_m_has_field_min_level'): return self._m_has_field_min_level self._m_has_field_min_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_level', None) @property def has_field_drop_tag(self): if hasattr(self, '_m_has_field_drop_tag'): return self._m_has_field_drop_tag self._m_has_field_drop_tag = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_drop_tag', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_drop_id', None) @property def has_field_drop_count(self): if hasattr(self, '_m_has_field_drop_count'): return self._m_has_field_drop_count self._m_has_field_drop_count = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_drop_count', None) class ActivityBannerExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterTitleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WatcherConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_config', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_progress', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_disuse', None) class LockTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDungunEntryType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungunEntryType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumInputEventTypeConfigBaseInputEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumInputEventType(self._io, self, self._root) self.value = Output.ConfigBaseInputEvent(self._io, self, self._root) class ConfigBuffDebuffAddition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_addition_buff_debuffs: self.addition_buff_debuffs = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) if self.has_field_addition_ratio: self.addition_ratio = self._io.read_f4le() @property def has_field_addition_buff_debuffs(self): if hasattr(self, '_m_has_field_addition_buff_debuffs'): return self._m_has_field_addition_buff_debuffs self._m_has_field_addition_buff_debuffs = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_addition_buff_debuffs', None) @property def has_field_addition_ratio(self): if hasattr(self, '_m_has_field_addition_ratio'): return self._m_has_field_addition_ratio self._m_has_field_addition_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_addition_ratio', None) class ShopmallEntranceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigEliteShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigEliteShieldResistance(self._io, self, self._root)) class ScenePropSyncMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tile_name: self.tile_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_world_type: self.is_world_type = self._io.read_u1() @property def has_field_tile_name(self): if hasattr(self, '_m_has_field_tile_name'): return self._m_has_field_tile_name self._m_has_field_tile_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tile_name', None) @property def has_field_is_world_type(self): if hasattr(self, '_m_has_field_is_world_type'): return self._m_has_field_is_world_type self._m_has_field_is_world_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_world_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ExhibitionSeriesTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfTransPointUpdateMaterialLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TransPointUpdateMaterial(self._io, self, self._root)) class ConfigCameraMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cfg_path: self.cfg_path = AuxTypes.String(self._io, self, self._root) @property def has_field_cfg_path(self): if hasattr(self, '_m_has_field_cfg_path'): return self._m_has_field_cfg_path self._m_has_field_cfg_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cfg_path', None) class KvpOfDictAuxTypesVlqBase128LeUCoopTempValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.CoopTempValue(self._io, self, self._root) class LunaRiteBattleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigCrowdSpawnInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdSpawnInfo(self._io, self, self._root)) class ConfigMainWidgetToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gadget_config_map: self.gadget_config_map = Output.DictOfAuxTypesVlqBase128LeUConfigWidgetGadget(self._io, self, self._root) if self.has_field_cd_group_config_map: self.cd_group_config_map = Output.DictOfAuxTypesVlqBase128LeUConfigWidgetCdGroup(self._io, self, self._root) if self.has_field_widget_config_map: self.widget_config_map = Output.DictOfAuxTypesVlqBase128LeUDispConfigBaseWidgetToy(self._io, self, self._root) @property def has_field_gadget_config_map(self): if hasattr(self, '_m_has_field_gadget_config_map'): return self._m_has_field_gadget_config_map self._m_has_field_gadget_config_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_config_map', None) @property def has_field_cd_group_config_map(self): if hasattr(self, '_m_has_field_cd_group_config_map'): return self._m_has_field_cd_group_config_map self._m_has_field_cd_group_config_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_group_config_map', None) @property def has_field_widget_config_map(self): if hasattr(self, '_m_has_field_widget_config_map'): return self._m_has_field_widget_config_map self._m_has_field_widget_config_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_widget_config_map', None) class KvpOfDictEnumOptionTypeConfigComprehensiveQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumOptionType(self._io, self, self._root) self.value = Output.ConfigComprehensiveQualitySetting(self._io, self, self._root) class ArrayOfConfigBattleFervorGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigBattleFervorGroup(self._io, self, self._root)) class ConfigGuideBanUiAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_ban_type: self.ui_ban_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_ui_ban_type(self): if hasattr(self, '_m_has_field_ui_ban_type'): return self._m_has_field_ui_ban_type self._m_has_field_ui_ban_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_ban_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class EnumConfigShadowResolution(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigShadowResolution, self.data.value) return getattr(self, '_m_value', None) class IgnoreMoveColToRockCol(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ignore: self.ignore = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_ignore(self): if hasattr(self, '_m_has_field_ignore'): return self._m_has_field_ignore self._m_has_field_ignore = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ignore', None) class ArrayOfConfigAiPickActionPointCriteriaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiPickActionPointCriteria(self._io, self, self._root)) class MpPlayLevelTextDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySummerTimeStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_main_quest: self.main_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest: self.pre_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_button_quest: self.guide_button_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_pushtips_id: self.guide_pushtips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_title: self.quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gameplay_title: self.gameplay_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gameplay_desc: self.gameplay_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_pre_quest(self): if hasattr(self, '_m_has_field_pre_quest'): return self._m_has_field_pre_quest self._m_has_field_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest', None) @property def has_field_guide_button_quest(self): if hasattr(self, '_m_has_field_guide_button_quest'): return self._m_has_field_guide_button_quest self._m_has_field_guide_button_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_guide_button_quest', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_gameplay_desc(self): if hasattr(self, '_m_has_field_gameplay_desc'): return self._m_has_field_gameplay_desc self._m_has_field_gameplay_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_gameplay_desc', None) @property def has_field_guide_pushtips_id(self): if hasattr(self, '_m_has_field_guide_pushtips_id'): return self._m_has_field_guide_pushtips_id self._m_has_field_guide_pushtips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_guide_pushtips_id', None) @property def has_field_quest_title(self): if hasattr(self, '_m_has_field_quest_title'): return self._m_has_field_quest_title self._m_has_field_quest_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_quest_title', None) @property def has_field_gameplay_title(self): if hasattr(self, '_m_has_field_gameplay_title'): return self._m_has_field_gameplay_title self._m_has_field_gameplay_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_gameplay_title', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_main_quest(self): if hasattr(self, '_m_has_field_main_quest'): return self._m_has_field_main_quest self._m_has_field_main_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_main_quest', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) class EnumBartenderCupType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BartenderCupType, self.data.value) return getattr(self, '_m_value', None) class TimerLimitTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelMonsterAiPatrol(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ai_patrol_group_id: self.ai_patrol_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ai_patrol_is_leader: self.ai_patrol_is_leader = self._io.read_u1() if self.has_field_ai_patrol_offset: self.ai_patrol_offset = Output.Point2d(self._io, self, self._root) @property def has_field_ai_patrol_group_id(self): if hasattr(self, '_m_has_field_ai_patrol_group_id'): return self._m_has_field_ai_patrol_group_id self._m_has_field_ai_patrol_group_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ai_patrol_group_id', None) @property def has_field_ai_patrol_is_leader(self): if hasattr(self, '_m_has_field_ai_patrol_is_leader'): return self._m_has_field_ai_patrol_is_leader self._m_has_field_ai_patrol_is_leader = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ai_patrol_is_leader', None) @property def has_field_ai_patrol_offset(self): if hasattr(self, '_m_has_field_ai_patrol_offset'): return self._m_has_field_ai_patrol_offset self._m_has_field_ai_patrol_offset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ai_patrol_offset', None) class IrodoriChessMapPointExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coord_x: self.coord_x = self._io.read_f4le() if self.has_field_coord_y: self.coord_y = self._io.read_f4le() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_coord_x(self): if hasattr(self, '_m_has_field_coord_x'): return self._m_has_field_coord_x self._m_has_field_coord_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_coord_x', None) @property def has_field_coord_y(self): if hasattr(self, '_m_has_field_coord_y'): return self._m_has_field_coord_y self._m_has_field_coord_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_coord_y', None) class RandomQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sub_id: self.sub_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_id: self.main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_sub_id_set: self.sub_id_set = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_accept_cond_comb: self.accept_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_accept_cond: self.accept_cond = Output.ArrayOfRandomQuestCondLengthS(self._io, self, self._root) if self.has_field_finish_cond_comb: self.finish_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_finish_cond: self.finish_cond = Output.ArrayOfRandomQuestContentLengthS(self._io, self, self._root) if self.has_field_fail_cond_comb: self.fail_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_fail_cond: self.fail_cond = Output.ArrayOfRandomQuestContentLengthS(self._io, self, self._root) if self.has_field_guide: self.guide = Output.QuestGuide(self._io, self, self._root) if self.has_field_show_guide: self.show_guide = Output.EnumShowQuestGuideType(self._io, self, self._root) if self.has_field_finish_parent: self.finish_parent = self._io.read_u1() if self.has_field_fail_parent: self.fail_parent = self._io.read_u1() if self.has_field_fail_parent_show: self.fail_parent_show = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_is_rewind: self.is_rewind = self._io.read_u1() if self.has_field_award_items: self.award_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_begin_exec: self.begin_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_fail_exec: self.fail_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_exclusive_npc_priority: self.exclusive_npc_priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ban_type: self.ban_type = Output.EnumBanGroupType(self._io, self, self._root) @property def has_field_finish_cond(self): if hasattr(self, '_m_has_field_finish_cond'): return self._m_has_field_finish_cond self._m_has_field_finish_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_finish_cond', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_ban_type(self): if hasattr(self, '_m_has_field_ban_type'): return self._m_has_field_ban_type self._m_has_field_ban_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_ban_type', None) @property def has_field_fail_cond(self): if hasattr(self, '_m_has_field_fail_cond'): return self._m_has_field_fail_cond self._m_has_field_fail_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_fail_cond', None) @property def has_field_is_rewind(self): if hasattr(self, '_m_has_field_is_rewind'): return self._m_has_field_is_rewind self._m_has_field_is_rewind = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_is_rewind', None) @property def has_field_finish_cond_comb(self): if hasattr(self, '_m_has_field_finish_cond_comb'): return self._m_has_field_finish_cond_comb self._m_has_field_finish_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_finish_cond_comb', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_finish_exec', None) @property def has_field_accept_cond_comb(self): if hasattr(self, '_m_has_field_accept_cond_comb'): return self._m_has_field_accept_cond_comb self._m_has_field_accept_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_accept_cond_comb', None) @property def has_field_main_id(self): if hasattr(self, '_m_has_field_main_id'): return self._m_has_field_main_id self._m_has_field_main_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_main_id', None) @property def has_field_sub_id_set(self): if hasattr(self, '_m_has_field_sub_id_set'): return self._m_has_field_sub_id_set self._m_has_field_sub_id_set = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sub_id_set', None) @property def has_field_fail_parent(self): if hasattr(self, '_m_has_field_fail_parent'): return self._m_has_field_fail_parent self._m_has_field_fail_parent = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_fail_parent', None) @property def has_field_fail_cond_comb(self): if hasattr(self, '_m_has_field_fail_cond_comb'): return self._m_has_field_fail_cond_comb self._m_has_field_fail_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_fail_cond_comb', None) @property def has_field_guide(self): if hasattr(self, '_m_has_field_guide'): return self._m_has_field_guide self._m_has_field_guide = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_guide', None) @property def has_field_exclusive_npc_priority(self): if hasattr(self, '_m_has_field_exclusive_npc_priority'): return self._m_has_field_exclusive_npc_priority self._m_has_field_exclusive_npc_priority = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_exclusive_npc_priority', None) @property def has_field_show_guide(self): if hasattr(self, '_m_has_field_show_guide'): return self._m_has_field_show_guide self._m_has_field_show_guide = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_show_guide', None) @property def has_field_begin_exec(self): if hasattr(self, '_m_has_field_begin_exec'): return self._m_has_field_begin_exec self._m_has_field_begin_exec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_begin_exec', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_type', None) @property def has_field_sub_id(self): if hasattr(self, '_m_has_field_sub_id'): return self._m_has_field_sub_id self._m_has_field_sub_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sub_id', None) @property def has_field_fail_exec(self): if hasattr(self, '_m_has_field_fail_exec'): return self._m_has_field_fail_exec self._m_has_field_fail_exec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_fail_exec', None) @property def has_field_accept_cond(self): if hasattr(self, '_m_has_field_accept_cond'): return self._m_has_field_accept_cond self._m_has_field_accept_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_accept_cond', None) @property def has_field_award_items(self): if hasattr(self, '_m_has_field_award_items'): return self._m_has_field_award_items self._m_has_field_award_items = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_award_items', None) @property def has_field_fail_parent_show(self): if hasattr(self, '_m_has_field_fail_parent_show'): return self._m_has_field_fail_parent_show self._m_has_field_fail_parent_show = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_fail_parent_show', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_finish_parent(self): if hasattr(self, '_m_has_field_finish_parent'): return self._m_has_field_finish_parent self._m_has_field_finish_parent = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_finish_parent', None) class MatchExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_match_sub_type: self.match_sub_type = Output.EnumMatchSubType(self._io, self, self._root) if self.has_field_min_player_num: self.min_player_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_player_num: self.max_player_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_confirm_time: self.confirm_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_continue_match: self.is_continue_match = self._io.read_u1() @property def has_field_is_continue_match(self): if hasattr(self, '_m_has_field_is_continue_match'): return self._m_has_field_is_continue_match self._m_has_field_is_continue_match = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_continue_match', None) @property def has_field_confirm_time(self): if hasattr(self, '_m_has_field_confirm_time'): return self._m_has_field_confirm_time self._m_has_field_confirm_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_confirm_time', None) @property def has_field_match_sub_type(self): if hasattr(self, '_m_has_field_match_sub_type'): return self._m_has_field_match_sub_type self._m_has_field_match_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_match_sub_type', None) @property def has_field_min_player_num(self): if hasattr(self, '_m_has_field_min_player_num'): return self._m_has_field_min_player_num self._m_has_field_min_player_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_min_player_num', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_max_player_num(self): if hasattr(self, '_m_has_field_max_player_num'): return self._m_has_field_max_player_num self._m_has_field_max_player_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_player_num', None) class ConfigCollision(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ccd: self.ccd = Output.ConfigCcd(self._io, self, self._root) if self.has_field_trigger_type: self.trigger_type = Output.EnumColliderTriggerType(self._io, self, self._root) if self.has_field_trigger_cd: self.trigger_cd = self._io.read_f4le() if self.has_field_target_type: self.target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_ignore_scene: self.ignore_scene = self._io.read_u1() if self.has_field_ignore_water: self.ignore_water = self._io.read_u1() if self.has_field_born_with_trigger_enabled: self.born_with_trigger_enabled = self._io.read_u1() if self.has_field_delay_enable_collision: self.delay_enable_collision = self._io.read_f4le() @property def has_field_born_with_trigger_enabled(self): if hasattr(self, '_m_has_field_born_with_trigger_enabled'): return self._m_has_field_born_with_trigger_enabled self._m_has_field_born_with_trigger_enabled = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_born_with_trigger_enabled', None) @property def has_field_trigger_type(self): if hasattr(self, '_m_has_field_trigger_type'): return self._m_has_field_trigger_type self._m_has_field_trigger_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_type', None) @property def has_field_trigger_cd(self): if hasattr(self, '_m_has_field_trigger_cd'): return self._m_has_field_trigger_cd self._m_has_field_trigger_cd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trigger_cd', None) @property def has_field_ccd(self): if hasattr(self, '_m_has_field_ccd'): return self._m_has_field_ccd self._m_has_field_ccd = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ccd', None) @property def has_field_ignore_scene(self): if hasattr(self, '_m_has_field_ignore_scene'): return self._m_has_field_ignore_scene self._m_has_field_ignore_scene = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ignore_scene', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_ignore_water(self): if hasattr(self, '_m_has_field_ignore_water'): return self._m_has_field_ignore_water self._m_has_field_ignore_water = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_ignore_water', None) @property def has_field_delay_enable_collision(self): if hasattr(self, '_m_has_field_delay_enable_collision'): return self._m_has_field_delay_enable_collision self._m_has_field_delay_enable_collision = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_delay_enable_collision', None) class ExpeditionDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_condition_vec: self.open_condition_vec = Output.ArrayOfExpeditionOpenConditionLengthS(self._io, self, self._root) if self.has_field_time_reward_vec: self.time_reward_vec = Output.ArrayOfExpeditionRewardLengthS(self._io, self, self._root) if self.has_field_description: self.description = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_picture: self.picture = AuxTypes.String(self._io, self, self._root) if self.has_field_pos_x: self.pos_x = self._io.read_f4le() if self.has_field_pos_y: self.pos_y = self._io.read_f4le() @property def has_field_open_condition_vec(self): if hasattr(self, '_m_has_field_open_condition_vec'): return self._m_has_field_open_condition_vec self._m_has_field_open_condition_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_condition_vec', None) @property def has_field_pos_x(self): if hasattr(self, '_m_has_field_pos_x'): return self._m_has_field_pos_x self._m_has_field_pos_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pos_x', None) @property def has_field_picture(self): if hasattr(self, '_m_has_field_picture'): return self._m_has_field_picture self._m_has_field_picture = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_picture', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_time_reward_vec(self): if hasattr(self, '_m_has_field_time_reward_vec'): return self._m_has_field_time_reward_vec self._m_has_field_time_reward_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_time_reward_vec', None) @property def has_field_pos_y(self): if hasattr(self, '_m_has_field_pos_y'): return self._m_has_field_pos_y self._m_has_field_pos_y = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_pos_y', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_description(self): if hasattr(self, '_m_has_field_description'): return self._m_has_field_description self._m_has_field_description = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_description', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ActivityGearGadgetJigsawExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAudioAmbiencePositionedEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioAmbiencePositionedEvent(self._io, self, self._root)) class TemplateParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param', None) class ConfigGuideLevelCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_limit_level: self.limit_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_less: self.is_less = self._io.read_u1() @property def has_field_limit_level(self): if hasattr(self, '_m_has_field_limit_level'): return self._m_has_field_limit_level self._m_has_field_limit_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_limit_level', None) @property def has_field_is_less(self): if hasattr(self, '_m_has_field_is_less'): return self._m_has_field_is_less self._m_has_field_is_less = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_less', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class DictOfAuxTypesStringAudioPlatformSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAudioPlatformSetting(self._io, self, self._root)) class MarkCustomTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigAttackAttenuation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAttackAttenuation(self._io, self, self._root)) class DictOfAuxTypesStringAuxTypesDynamicFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAuxTypesDynamicFloat(self._io, self, self._root)) class EnumTriggerMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TriggerMode, self.data.value) return getattr(self, '_m_value', None) class FleurFairTipsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByMonsterAirState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_air_move: self.is_air_move = self._io.read_u1() @property def has_field_is_air_move(self): if hasattr(self, '_m_has_field_is_air_move'): return self._m_has_field_is_air_move self._m_has_field_is_air_move = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_air_move', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumFireworksReformParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FireworksReformParamType, self.data.value) return getattr(self, '_m_value', None) class EnumTeamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TeamType, self.data.value) return getattr(self, '_m_value', None) class ConfigScheduleJobTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUFaceAnimationTSettingPathConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUFaceAnimationTSettingPathConfig(self._io, self, self._root)) class InvestigationTargetConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBaseInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigCameraMoveInterAction(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigDialogNextAction(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigVisibleInterAction(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBaseInterAction(self._io, self, self._root) elif _on == 47: self.data = Output.ConfigBanSelfGlobalValue(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigEmotionInterAction(self._io, self, self._root) elif _on == 42: self.data = Output.ConfigHideWidgetPet(self._io, self, self._root) elif _on == 46: self.data = Output.ConfigPlayerNpcEnergyTypeAction(self._io, self, self._root) elif _on == 39: self.data = Output.ConfigSetAnimatorAction(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigVideoPlayAction(self._io, self, self._root) elif _on == 35: self.data = Output.ConfigEmotionTemplateAction(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigUiTriggerInterAction(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigGadgetTouchAction(self._io, self, self._root) elif _on == 32: self.data = Output.ConfigSimpleUiShowInterAction(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigBlackScreenAction(self._io, self, self._root) elif _on == 1: self.data = Output.AreaUnlockInterAction(self._io, self, self._root) elif _on == 27: self.data = Output.ConfigMoveToAction(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigLookAtEyeCtrlInterAction(self._io, self, self._root) elif _on == 52: self.data = Output.ConfigCloseGpuCullingInterAction(self._io, self, self._root) elif _on == 45: self.data = Output.ConfigChangeNpcMatAction(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigDialogSelectAction(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigLookAtInterAction(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigEmoSyncInterAction(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigSteerInterAction(self._io, self, self._root) elif _on == 33: self.data = Output.ConfigOpenBlossomMarkInterAction(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigShopExchangeInterAction(self._io, self, self._root) elif _on == 51: self.data = Output.ConfigSpawnAttachInterAction(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigAudioPlayAction(self._io, self, self._root) elif _on == 48: self.data = Output.ConfigSetModelTransform(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigCameraSplineInterAction(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigLuaAction(self._io, self, self._root) elif _on == 38: self.data = Output.ConfigTeleportToAction(self._io, self, self._root) elif _on == 40: self.data = Output.ConfigPlayPostEffectAction(self._io, self, self._root) elif _on == 44: self.data = Output.ConfigPlayUiEffectAction(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigDialogInterAction(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigCameraShakeAction(self._io, self, self._root) elif _on == 37: self.data = Output.ConfigPlayEffectAction(self._io, self, self._root) elif _on == 41: self.data = Output.ConfigPlayFrameFaceAnimationAction(self._io, self, self._root) elif _on == 36: self.data = Output.ConfigSitOrStandAction(self._io, self, self._root) elif _on == 28: self.data = Output.ConfigRequestMsgAction(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigCutsceneInterAction(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigAudioStateInterAction(self._io, self, self._root) elif _on == 26: self.data = Output.ConfigCameraDofAction(self._io, self, self._root) elif _on == 31: self.data = Output.ConfigSimpleBlackScreenAction(self._io, self, self._root) elif _on == 49: self.data = Output.ConfigSpecialElementViewAction(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBodyLangInterAction(self._io, self, self._root) elif _on == 34: self.data = Output.ConfigSpeechBubbleAction(self._io, self, self._root) elif _on == 29: self.data = Output.ConfigEmojiBubbleAction(self._io, self, self._root) elif _on == 25: self.data = Output.ConfigFirstSightAction(self._io, self, self._root) elif _on == 43: self.data = Output.ConfigLocalGadgetOp(self._io, self, self._root) elif _on == 50: self.data = Output.ConfigChangeTimeInterAction(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigShowMessageAction(self._io, self, self._root) elif _on == 30: self.data = Output.ConfigTimeProtectAction(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DictOfAuxTypesStringConfigAbilityPropertyEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAbilityPropertyEntry(self._io, self, self._root)) class DailyTaskTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicStringStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_string_param: self.string_param = AuxTypes.String(self._io, self, self._root) @property def has_field_string_param(self): if hasattr(self, '_m_has_field_string_param'): return self._m_has_field_string_param self._m_has_field_string_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_string_param', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class EnumCombatBillboardSize(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CombatBillboardSize, self.data.value) return getattr(self, '_m_value', None) class BoredMonsterPoolConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_tag: self.drop_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_affix_vec: self.affix_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_elite: self.is_elite = self._io.read_u1() @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_is_elite(self): if hasattr(self, '_m_has_field_is_elite'): return self._m_has_field_is_elite self._m_has_field_is_elite = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_elite', None) @property def has_field_drop_tag(self): if hasattr(self, '_m_has_field_drop_tag'): return self._m_has_field_drop_tag self._m_has_field_drop_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_drop_tag', None) @property def has_field_affix_vec(self): if hasattr(self, '_m_has_field_affix_vec'): return self._m_has_field_affix_vec self._m_has_field_affix_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_affix_vec', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ArrayOfConfigKeyframeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigKeyframe(self._io, self, self._root)) class CustomLevelUiConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_info: self.level_info = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_level_info(self): if hasattr(self, '_m_has_field_level_info'): return self._m_has_field_level_info self._m_has_field_level_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_info', None) class AttachToGadgetStateMutexMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_states: self.gadget_states = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_modifier_names: self.modifier_names = Output.ArrayOfArrayOfAuxTypesStringLengthULengthU(self._io, self, self._root) @property def has_field_gadget_states(self): if hasattr(self, '_m_has_field_gadget_states'): return self._m_has_field_gadget_states self._m_has_field_gadget_states = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_states', None) @property def has_field_modifier_names(self): if hasattr(self, '_m_has_field_modifier_names'): return self._m_has_field_modifier_names self._m_has_field_modifier_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_names', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigWidgetFireworksLauncher(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetToyCreateGadgetBase(self._io, self, self._root) @property def is_set_camera(self): if hasattr(self, '_m_is_set_camera'): return self._m_is_set_camera self._m_is_set_camera = self.base.is_set_camera return getattr(self, '_m_is_set_camera', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def set_camera_angle(self): if hasattr(self, '_m_set_camera_angle'): return self._m_set_camera_angle self._m_set_camera_angle = self.base.set_camera_angle return getattr(self, '_m_set_camera_angle', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def do_bag_type(self): if hasattr(self, '_m_do_bag_type'): return self._m_do_bag_type self._m_do_bag_type = self.base.do_bag_type return getattr(self, '_m_do_bag_type', None) class SectrSectorRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProjectionGameGuideInputModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GlobalValuePair(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_random_in_range: self.random_in_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def has_field_random_in_range(self): if hasattr(self, '_m_has_field_random_in_range'): return self._m_has_field_random_in_range self._m_has_field_random_in_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_in_range', None) class LanV2overAllDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_dungeon_id: self.boss_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_reward_id: self.boss_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_start_day: self.boss_start_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_watcher_id_list: self.boss_watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_boss_exhibition_id_list: self.boss_exhibition_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_boss_push_tips_id: self.boss_push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_clothes_watcher_id_list: self.clothes_watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_clothes_reward_id: self.clothes_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_card_id_list: self.boss_card_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_activity_play_duration: self.activity_play_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hide_exchange_entry: self.hide_exchange_entry = self._io.read_u1() @property def has_field_boss_exhibition_id_list(self): if hasattr(self, '_m_has_field_boss_exhibition_id_list'): return self._m_has_field_boss_exhibition_id_list self._m_has_field_boss_exhibition_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_boss_exhibition_id_list', None) @property def has_field_clothes_reward_id(self): if hasattr(self, '_m_has_field_clothes_reward_id'): return self._m_has_field_clothes_reward_id self._m_has_field_clothes_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_clothes_reward_id', None) @property def has_field_clothes_watcher_id_list(self): if hasattr(self, '_m_has_field_clothes_watcher_id_list'): return self._m_has_field_clothes_watcher_id_list self._m_has_field_clothes_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_clothes_watcher_id_list', None) @property def has_field_activity_play_duration(self): if hasattr(self, '_m_has_field_activity_play_duration'): return self._m_has_field_activity_play_duration self._m_has_field_activity_play_duration = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_activity_play_duration', None) @property def has_field_boss_watcher_id_list(self): if hasattr(self, '_m_has_field_boss_watcher_id_list'): return self._m_has_field_boss_watcher_id_list self._m_has_field_boss_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_boss_watcher_id_list', None) @property def has_field_boss_start_day(self): if hasattr(self, '_m_has_field_boss_start_day'): return self._m_has_field_boss_start_day self._m_has_field_boss_start_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_boss_start_day', None) @property def has_field_boss_reward_id(self): if hasattr(self, '_m_has_field_boss_reward_id'): return self._m_has_field_boss_reward_id self._m_has_field_boss_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_boss_reward_id', None) @property def has_field_boss_dungeon_id(self): if hasattr(self, '_m_has_field_boss_dungeon_id'): return self._m_has_field_boss_dungeon_id self._m_has_field_boss_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_boss_dungeon_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hide_exchange_entry(self): if hasattr(self, '_m_has_field_hide_exchange_entry'): return self._m_has_field_hide_exchange_entry self._m_has_field_hide_exchange_entry = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_hide_exchange_entry', None) @property def has_field_boss_card_id_list(self): if hasattr(self, '_m_has_field_boss_card_id_list'): return self._m_has_field_boss_card_id_list self._m_has_field_boss_card_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_boss_card_id_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_boss_push_tips_id(self): if hasattr(self, '_m_has_field_boss_push_tips_id'): return self._m_has_field_boss_push_tips_id self._m_has_field_boss_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_boss_push_tips_id', None) class FishSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTurnMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TurnMode, self.data.value) return getattr(self, '_m_value', None) class ArrayOfActivityShopSheetCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ActivityShopSheetCond(self._io, self, self._root)) class ConfigAiMixinSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_set_controller_parameter_on_be_hit_by_entity_type: self.set_controller_parameter_on_be_hit_by_entity_type = Output.ArrayOfConfigAiMixinSetControllerConditionLengthU(self._io, self, self._root) @property def has_field_set_controller_parameter_on_be_hit_by_entity_type(self): if hasattr(self, '_m_has_field_set_controller_parameter_on_be_hit_by_entity_type'): return self._m_has_field_set_controller_parameter_on_be_hit_by_entity_type self._m_has_field_set_controller_parameter_on_be_hit_by_entity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_controller_parameter_on_be_hit_by_entity_type', None) class DungeonSlipRevivePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) if self.has_field_is_active: self.is_active = self._io.read_u1() if self.has_field_group_ids: self.group_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_active', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_size', None) @property def has_field_group_ids(self): if hasattr(self, '_m_has_field_group_ids'): return self._m_has_field_group_ids self._m_has_field_group_ids = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_group_ids', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class FlowSuiteOperatePolicyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGroupLinkRewardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomQuestEntranceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FlightActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachToWidgetStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_widget_material_id: self.target_widget_material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_on_active: self.on_active = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_disable: self.on_disable = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_removed: self.on_removed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_active(self): if hasattr(self, '_m_has_field_on_active'): return self._m_has_field_on_active self._m_has_field_on_active = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_active', None) @property def has_field_target_widget_material_id(self): if hasattr(self, '_m_has_field_target_widget_material_id'): return self._m_has_field_target_widget_material_id self._m_has_field_target_widget_material_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_widget_material_id', None) @property def has_field_on_removed(self): if hasattr(self, '_m_has_field_on_removed'): return self._m_has_field_on_removed self._m_has_field_on_removed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_removed', None) @property def has_field_on_disable(self): if hasattr(self, '_m_has_field_on_disable'): return self._m_has_field_on_disable self._m_has_field_on_disable = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_disable', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EventType, self.data.value) return getattr(self, '_m_value', None) class BuoyantCombatExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPotionModeChoiceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumOrderingType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OrderingType, self.data.value) return getattr(self, '_m_value', None) class EchoShellSummerTimeDungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_chest_count: self.total_chest_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_shell_count: self.total_shell_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_total_chest_count(self): if hasattr(self, '_m_has_field_total_chest_count'): return self._m_has_field_total_chest_count self._m_has_field_total_chest_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_total_chest_count', None) @property def has_field_total_shell_count(self): if hasattr(self, '_m_has_field_total_shell_count'): return self._m_has_field_total_shell_count self._m_has_field_total_shell_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_total_shell_count', None) class ConfigSurroundBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_clockwise: self.clockwise = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_trace_on_y_axis: self.trace_on_y_axis = self._io.read_u1() if self.has_field_destroy_when_target_die: self.destroy_when_target_die = self._io.read_u1() @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def has_field_destroy_when_target_die(self): if hasattr(self, '_m_has_field_destroy_when_target_die'): return self._m_has_field_destroy_when_target_die self._m_has_field_destroy_when_target_die = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_destroy_when_target_die', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def has_field_trace_on_y_axis(self): if hasattr(self, '_m_has_field_trace_on_y_axis'): return self._m_has_field_trace_on_y_axis self._m_has_field_trace_on_y_axis = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trace_on_y_axis', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) @property def has_field_clockwise(self): if hasattr(self, '_m_has_field_clockwise'): return self._m_has_field_clockwise self._m_has_field_clockwise = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_clockwise', None) class ConfigAbilityActionToken(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cancel_with_entity_tick_lod: self.cancel_with_entity_tick_lod = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_channel_id: self.channel_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_token_cost_type: self.token_cost_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_token_type: self.token_type = Output.EnumActionTokenType(self._io, self, self._root) @property def has_field_token_cost_type(self): if hasattr(self, '_m_has_field_token_cost_type'): return self._m_has_field_token_cost_type self._m_has_field_token_cost_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_token_cost_type', None) @property def has_field_token_type(self): if hasattr(self, '_m_has_field_token_type'): return self._m_has_field_token_type self._m_has_field_token_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_token_type', None) @property def has_field_channel_id(self): if hasattr(self, '_m_has_field_channel_id'): return self._m_has_field_channel_id self._m_has_field_channel_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_channel_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_cancel_with_entity_tick_lod(self): if hasattr(self, '_m_has_field_cancel_with_entity_tick_lod'): return self._m_has_field_cancel_with_entity_tick_lod self._m_has_field_cancel_with_entity_tick_lod = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cancel_with_entity_tick_lod', None) class ConfigElementReactionCoefficients(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_coefficient_overdose: self.coefficient_overdose = self._io.read_f4le() @property def has_field_coefficient_overdose(self): if hasattr(self, '_m_has_field_coefficient_overdose'): return self._m_has_field_coefficient_overdose self._m_has_field_coefficient_overdose = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_coefficient_overdose', None) class FleurFairDungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_section_id: self.section_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_obtain_coin_limit: self.obtain_coin_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mini_game_list: self.mini_game_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_monster_list: self.monster_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_energy_grade_list: self.energy_grade_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_initial_energy: self.initial_energy = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_energy_limit: self.energy_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_reward_id: self.success_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_failure_reward_id: self.failure_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_punish_time: self.punish_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_mini_game_list(self): if hasattr(self, '_m_has_field_mini_game_list'): return self._m_has_field_mini_game_list self._m_has_field_mini_game_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mini_game_list', None) @property def has_field_punish_time(self): if hasattr(self, '_m_has_field_punish_time'): return self._m_has_field_punish_time self._m_has_field_punish_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_punish_time', None) @property def has_field_energy_limit(self): if hasattr(self, '_m_has_field_energy_limit'): return self._m_has_field_energy_limit self._m_has_field_energy_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_energy_limit', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_obtain_coin_limit(self): if hasattr(self, '_m_has_field_obtain_coin_limit'): return self._m_has_field_obtain_coin_limit self._m_has_field_obtain_coin_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_obtain_coin_limit', None) @property def has_field_success_reward_id(self): if hasattr(self, '_m_has_field_success_reward_id'): return self._m_has_field_success_reward_id self._m_has_field_success_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_success_reward_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_monster_list(self): if hasattr(self, '_m_has_field_monster_list'): return self._m_has_field_monster_list self._m_has_field_monster_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_monster_list', None) @property def has_field_failure_reward_id(self): if hasattr(self, '_m_has_field_failure_reward_id'): return self._m_has_field_failure_reward_id self._m_has_field_failure_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_failure_reward_id', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_section_id(self): if hasattr(self, '_m_has_field_section_id'): return self._m_has_field_section_id self._m_has_field_section_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_section_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_initial_energy(self): if hasattr(self, '_m_has_field_initial_energy'): return self._m_has_field_initial_energy self._m_has_field_initial_energy = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_initial_energy', None) @property def has_field_energy_grade_list(self): if hasattr(self, '_m_has_field_energy_grade_list'): return self._m_has_field_energy_grade_list self._m_has_field_energy_grade_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_energy_grade_list', None) class ConfigAiNeuronExtSettings(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hit_buddy: self.hit_buddy = Output.ConfigAiNeuronHitBuddySetting(self._io, self, self._root) @property def has_field_hit_buddy(self): if hasattr(self, '_m_has_field_hit_buddy'): return self._m_has_field_hit_buddy self._m_has_field_hit_buddy = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_buddy', None) class LoadingTipsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tips_title: self.tips_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tips_desc: self.tips_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.String(self._io, self, self._root) if self.has_field_start_time: self.start_time = AuxTypes.String(self._io, self, self._root) if self.has_field_end_time: self.end_time = AuxTypes.String(self._io, self, self._root) if self.has_field_min_level: self.min_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_level: self.max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_open_state: self.limit_open_state = AuxTypes.String(self._io, self, self._root) if self.has_field_pre_main_quest_ids: self.pre_main_quest_ids = AuxTypes.String(self._io, self, self._root) if self.has_field_pre_quest_id_list: self.pre_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_disable_quest_id_list: self.disable_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_enable_dungeon_id: self.enable_dungeon_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_disable_quest_id_list(self): if hasattr(self, '_m_has_field_disable_quest_id_list'): return self._m_has_field_disable_quest_id_list self._m_has_field_disable_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_disable_quest_id_list', None) @property def has_field_pre_quest_id_list(self): if hasattr(self, '_m_has_field_pre_quest_id_list'): return self._m_has_field_pre_quest_id_list self._m_has_field_pre_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_pre_quest_id_list', None) @property def has_field_limit_open_state(self): if hasattr(self, '_m_has_field_limit_open_state'): return self._m_has_field_limit_open_state self._m_has_field_limit_open_state = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_limit_open_state', None) @property def has_field_end_time(self): if hasattr(self, '_m_has_field_end_time'): return self._m_has_field_end_time self._m_has_field_end_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_end_time', None) @property def has_field_tips_title(self): if hasattr(self, '_m_has_field_tips_title'): return self._m_has_field_tips_title self._m_has_field_tips_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tips_title', None) @property def has_field_tips_desc(self): if hasattr(self, '_m_has_field_tips_desc'): return self._m_has_field_tips_desc self._m_has_field_tips_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tips_desc', None) @property def has_field_pre_main_quest_ids(self): if hasattr(self, '_m_has_field_pre_main_quest_ids'): return self._m_has_field_pre_main_quest_ids self._m_has_field_pre_main_quest_ids = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_pre_main_quest_ids', None) @property def has_field_min_level(self): if hasattr(self, '_m_has_field_min_level'): return self._m_has_field_min_level self._m_has_field_min_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_min_level', None) @property def has_field_enable_dungeon_id(self): if hasattr(self, '_m_has_field_enable_dungeon_id'): return self._m_has_field_enable_dungeon_id self._m_has_field_enable_dungeon_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_enable_dungeon_id', None) @property def has_field_max_level(self): if hasattr(self, '_m_has_field_max_level'): return self._m_has_field_max_level self._m_has_field_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_max_level', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_start_time(self): if hasattr(self, '_m_has_field_start_time'): return self._m_has_field_start_time self._m_has_field_start_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_start_time', None) class UidOpNotifyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CurLocalAvatarMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfMonsterConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MonsterConfig(self._io, self, self._root)) class ConfigAiTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_target_prioritys: self.default_target_prioritys = Output.ArrayOfEnumAiTargetSystemTypeLengthU(self._io, self, self._root) if self.has_field_specification_target_prioritys: self.specification_target_prioritys = Output.DictOfAuxTypesVlqBase128LeSArrayOfEnumAiTargetSystemTypeLengthU(self._io, self, self._root) @property def has_field_default_target_prioritys(self): if hasattr(self, '_m_has_field_default_target_prioritys'): return self._m_has_field_default_target_prioritys self._m_has_field_default_target_prioritys = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_target_prioritys', None) @property def has_field_specification_target_prioritys(self): if hasattr(self, '_m_has_field_specification_target_prioritys'): return self._m_has_field_specification_target_prioritys self._m_has_field_specification_target_prioritys = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification_target_prioritys', None) class LuminanceStoneChallengeStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WinterCampRaceItemTipsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfStringKeyItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_value: self.override_value = AuxTypes.String(self._io, self, self._root) @property def has_field_override_value(self): if hasattr(self, '_m_has_field_override_value'): return self._m_has_field_override_value self._m_has_field_override_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_value', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) class MaterialSourceDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldLeastShopExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pool_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_count', None) class KvpOfDictAuxTypesStringConfigAttachment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAttachment(self._io, self, self._root) class PushPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pos_type: self.pos_type = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_save_to: self.save_to = Output.EnumAbilityTargetting(self._io, self, self._root) @property def has_field_save_to(self): if hasattr(self, '_m_has_field_save_to'): return self._m_has_field_save_to self._m_has_field_save_to = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_save_to', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_pos_type(self): if hasattr(self, '_m_has_field_pos_type'): return self._m_has_field_pos_type self._m_has_field_pos_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pos_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiFindBackData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_overtime: self.overtime = self._io.read_f4le() if self.has_field_target_lr_space: self.target_lr_space = self._io.read_f4le() if self.has_field_target_back_space: self.target_back_space = self._io.read_f4le() @property def has_field_overtime(self): if hasattr(self, '_m_has_field_overtime'): return self._m_has_field_overtime self._m_has_field_overtime = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_overtime', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_target_lr_space(self): if hasattr(self, '_m_has_field_target_lr_space'): return self._m_has_field_target_lr_space self._m_has_field_target_lr_space = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_target_lr_space', None) @property def has_field_target_back_space(self): if hasattr(self, '_m_has_field_target_back_space'): return self._m_has_field_target_back_space self._m_has_field_target_back_space = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_target_back_space', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class BeFollowStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExpeditionActivityPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prequest_id: self.prequest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_city_id: self.npc_city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_prequest_id(self): if hasattr(self, '_m_has_field_prequest_id'): return self._m_has_field_prequest_id self._m_has_field_prequest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_prequest_id', None) @property def has_field_npc_city_id(self): if hasattr(self, '_m_has_field_npc_city_id'): return self._m_has_field_npc_city_id self._m_has_field_npc_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_npc_city_id', None) class ElementCoeffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BillboardFixedMarkMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_prefab_name: self.prefab_name = AuxTypes.String(self._io, self, self._root) if self.has_field_only_show_in_element_view: self.only_show_in_element_view = self._io.read_u1() @property def has_field_prefab_name(self): if hasattr(self, '_m_has_field_prefab_name'): return self._m_has_field_prefab_name self._m_has_field_prefab_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_prefab_name', None) @property def has_field_only_show_in_element_view(self): if hasattr(self, '_m_has_field_only_show_in_element_view'): return self._m_has_field_only_show_in_element_view self._m_has_field_only_show_in_element_view = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_only_show_in_element_view', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class GadgetInteractExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicKeyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigLogoPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigLogoPage(self._io, self, self._root) class DropSubfield(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_subfield_name: self.subfield_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_subfield_name(self): if hasattr(self, '_m_has_field_subfield_name'): return self._m_has_field_subfield_name self._m_has_field_subfield_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_subfield_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumChessCardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigAudioIncrementalResources(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAudioIncrementalResources(self._io, self, self._root)) class AvatarFashionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DestroyTile(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tile_name: self.tile_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attack_pattern: self.attack_pattern = Output.DispConfigBaseAttackPattern(self._io, self, self._root) @property def has_field_tile_name(self): if hasattr(self, '_m_has_field_tile_name'): return self._m_has_field_tile_name self._m_has_field_tile_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tile_name', None) @property def has_field_attack_pattern(self): if hasattr(self, '_m_has_field_attack_pattern'): return self._m_has_field_attack_pattern self._m_has_field_attack_pattern = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attack_pattern', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigRecordPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bool_list: self.bool_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_int_list: self.int_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_float_list: self.float_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_trigger_list: self.trigger_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_bool_list(self): if hasattr(self, '_m_has_field_bool_list'): return self._m_has_field_bool_list self._m_has_field_bool_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bool_list', None) @property def has_field_int_list(self): if hasattr(self, '_m_has_field_int_list'): return self._m_has_field_int_list self._m_has_field_int_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_int_list', None) @property def has_field_float_list(self): if hasattr(self, '_m_has_field_float_list'): return self._m_has_field_float_list self._m_has_field_float_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_float_list', None) @property def has_field_trigger_list(self): if hasattr(self, '_m_has_field_trigger_list'): return self._m_has_field_trigger_list self._m_has_field_trigger_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_trigger_list', None) class MonsterSizeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MiracleRingDropExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_miracle_tag: self.miracle_tag = Output.EnumMiracleTag(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_miracle_tag(self): if hasattr(self, '_m_has_field_miracle_tag'): return self._m_has_field_miracle_tag self._m_has_field_miracle_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_miracle_tag', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_drop_id', None) class CircleBarrageMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bullet_id: self.bullet_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_inner_radius: self.inner_radius = self._io.read_f4le() if self.has_field_cut_num: self.cut_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_wave_num: self.wave_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_wave_cd: self.wave_cd = self._io.read_f4le() if self.has_field_wavebullet_num: self.wavebullet_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_waveangle: self.waveangle = self._io.read_f4le() if self.has_field_trigger_cd: self.trigger_cd = self._io.read_f4le() if self.has_field_shoot_point: self.shoot_point = AuxTypes.String(self._io, self, self._root) @property def has_field_cut_num(self): if hasattr(self, '_m_has_field_cut_num'): return self._m_has_field_cut_num self._m_has_field_cut_num = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_cut_num', None) @property def has_field_waveangle(self): if hasattr(self, '_m_has_field_waveangle'): return self._m_has_field_waveangle self._m_has_field_waveangle = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_waveangle', None) @property def has_field_bullet_id(self): if hasattr(self, '_m_has_field_bullet_id'): return self._m_has_field_bullet_id self._m_has_field_bullet_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_bullet_id', None) @property def has_field_wavebullet_num(self): if hasattr(self, '_m_has_field_wavebullet_num'): return self._m_has_field_wavebullet_num self._m_has_field_wavebullet_num = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_wavebullet_num', None) @property def has_field_shoot_point(self): if hasattr(self, '_m_has_field_shoot_point'): return self._m_has_field_shoot_point self._m_has_field_shoot_point = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_shoot_point', None) @property def has_field_wave_cd(self): if hasattr(self, '_m_has_field_wave_cd'): return self._m_has_field_wave_cd self._m_has_field_wave_cd = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_wave_cd', None) @property def has_field_wave_num(self): if hasattr(self, '_m_has_field_wave_num'): return self._m_has_field_wave_num self._m_has_field_wave_num = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_wave_num', None) @property def has_field_trigger_cd(self): if hasattr(self, '_m_has_field_trigger_cd'): return self._m_has_field_trigger_cd self._m_has_field_trigger_cd = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_trigger_cd', None) @property def has_field_inner_radius(self): if hasattr(self, '_m_has_field_inner_radius'): return self._m_has_field_inner_radius self._m_has_field_inner_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_inner_radius', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigPerfCombinedItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfCombineItemOptionArrayInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) class ShowReminder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_local_only: self.local_only = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_local_only(self): if hasattr(self, '_m_has_field_local_only'): return self._m_has_field_local_only self._m_has_field_local_only = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_local_only', None) class EnumFishSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FishSkillType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigCrowdActivityRestrictionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdActivityRestriction(self._io, self, self._root)) class MatchLimitTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ScoreRule(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_rule_name: self.rule_name = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_mode: self.trigger_mode = Output.EnumTriggerMode(self._io, self, self._root) if self.has_field_property_names: self.property_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_min_select_count: self.min_select_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_max_select_count: self.max_select_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_add_to_score_view: self.add_to_score_view = self._io.read_u1() @property def has_field_min_select_count(self): if hasattr(self, '_m_has_field_min_select_count'): return self._m_has_field_min_select_count self._m_has_field_min_select_count = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_select_count', None) @property def has_field_max_select_count(self): if hasattr(self, '_m_has_field_max_select_count'): return self._m_has_field_max_select_count self._m_has_field_max_select_count = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_select_count', None) @property def has_field_add_to_score_view(self): if hasattr(self, '_m_has_field_add_to_score_view'): return self._m_has_field_add_to_score_view self._m_has_field_add_to_score_view = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_add_to_score_view', None) @property def has_field_property_names(self): if hasattr(self, '_m_has_field_property_names'): return self._m_has_field_property_names self._m_has_field_property_names = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_property_names', None) @property def has_field_rule_name(self): if hasattr(self, '_m_has_field_rule_name'): return self._m_has_field_rule_name self._m_has_field_rule_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_rule_name', None) @property def has_field_trigger_mode(self): if hasattr(self, '_m_has_field_trigger_mode'): return self._m_has_field_trigger_mode self._m_has_field_trigger_mode = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_mode', None) class QuestPlaceConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WinterCampExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id01list: self.quest_id01list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_id02: self.quest_id02 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id02guide: self.quest_id02guide = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_qurest_id: self.activity_qurest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_chapt3quest_id: self.chapt3quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_id02: self.cond_id02 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id03: self.cond_id03 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_quest_id: self.boss_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_boss_cond_id: self.boss_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_watcher: self.boss_watcher = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_battle_tutorial_id: self.battle_tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explore_tutorial_id: self.explore_tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_race_tutorial_id: self.race_tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_snowman_tutorial_id: self.snowman_tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_race_tutorial_id(self): if hasattr(self, '_m_has_field_race_tutorial_id'): return self._m_has_field_race_tutorial_id self._m_has_field_race_tutorial_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_race_tutorial_id', None) @property def has_field_snowman_tutorial_id(self): if hasattr(self, '_m_has_field_snowman_tutorial_id'): return self._m_has_field_snowman_tutorial_id self._m_has_field_snowman_tutorial_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_snowman_tutorial_id', None) @property def has_field_boss_quest_id(self): if hasattr(self, '_m_has_field_boss_quest_id'): return self._m_has_field_boss_quest_id self._m_has_field_boss_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_boss_quest_id', None) @property def has_field_cond_id02(self): if hasattr(self, '_m_has_field_cond_id02'): return self._m_has_field_cond_id02 self._m_has_field_cond_id02 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cond_id02', None) @property def has_field_boss_watcher(self): if hasattr(self, '_m_has_field_boss_watcher'): return self._m_has_field_boss_watcher self._m_has_field_boss_watcher = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_boss_watcher', None) @property def has_field_battle_tutorial_id(self): if hasattr(self, '_m_has_field_battle_tutorial_id'): return self._m_has_field_battle_tutorial_id self._m_has_field_battle_tutorial_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_battle_tutorial_id', None) @property def has_field_boss_cond_id(self): if hasattr(self, '_m_has_field_boss_cond_id'): return self._m_has_field_boss_cond_id self._m_has_field_boss_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_boss_cond_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_chapt3quest_id(self): if hasattr(self, '_m_has_field_chapt3quest_id'): return self._m_has_field_chapt3quest_id self._m_has_field_chapt3quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_chapt3quest_id', None) @property def has_field_cond_id03(self): if hasattr(self, '_m_has_field_cond_id03'): return self._m_has_field_cond_id03 self._m_has_field_cond_id03 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cond_id03', None) @property def has_field_quest_id02guide(self): if hasattr(self, '_m_has_field_quest_id02guide'): return self._m_has_field_quest_id02guide self._m_has_field_quest_id02guide = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_id02guide', None) @property def has_field_quest_id01list(self): if hasattr(self, '_m_has_field_quest_id01list'): return self._m_has_field_quest_id01list self._m_has_field_quest_id01list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quest_id01list', None) @property def has_field_quest_id02(self): if hasattr(self, '_m_has_field_quest_id02'): return self._m_has_field_quest_id02 self._m_has_field_quest_id02 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_id02', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_explore_tutorial_id(self): if hasattr(self, '_m_has_field_explore_tutorial_id'): return self._m_has_field_explore_tutorial_id self._m_has_field_explore_tutorial_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_explore_tutorial_id', None) @property def has_field_activity_qurest_id(self): if hasattr(self, '_m_has_field_activity_qurest_id'): return self._m_has_field_activity_qurest_id self._m_has_field_activity_qurest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_activity_qurest_id', None) class EnumCoopPointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopPointType, self.data.value) return getattr(self, '_m_value', None) class FireworksLaunchExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigJudgeNodeBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_node_id: self.node_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_node_id(self): if hasattr(self, '_m_has_field_node_id'): return self._m_has_field_node_id self._m_has_field_node_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_node_id', None) class VelocityDetectMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_min_speed: self.min_speed = self._io.read_f4le() if self.has_field_max_speed: self.max_speed = self._io.read_f4le() if self.has_field_detect_on_start: self.detect_on_start = self._io.read_u1() if self.has_field_on_poseedge: self.on_poseedge = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_negedge: self.on_negedge = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_detect_on_start(self): if hasattr(self, '_m_has_field_detect_on_start'): return self._m_has_field_detect_on_start self._m_has_field_detect_on_start = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_detect_on_start', None) @property def has_field_max_speed(self): if hasattr(self, '_m_has_field_max_speed'): return self._m_has_field_max_speed self._m_has_field_max_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_speed', None) @property def has_field_on_negedge(self): if hasattr(self, '_m_has_field_on_negedge'): return self._m_has_field_on_negedge self._m_has_field_on_negedge = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_negedge', None) @property def has_field_min_speed(self): if hasattr(self, '_m_has_field_min_speed'): return self._m_has_field_min_speed self._m_has_field_min_speed = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_speed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_on_poseedge(self): if hasattr(self, '_m_has_field_on_poseedge'): return self._m_has_field_on_poseedge self._m_has_field_on_poseedge = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_poseedge', None) class ConfigMoveToAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_move_type: self.move_type = Output.EnumMoveToType(self._io, self, self._root) if self.has_field_route_list: self.route_list = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_exactly_move: self.exactly_move = self._io.read_u1() if self.has_field_move_dir_type: self.move_dir_type = Output.EnumMoveToDirectionType(self._io, self, self._root) if self.has_field_close_nav_mesh: self.close_nav_mesh = self._io.read_u1() if self.has_field_direct_move_speed: self.direct_move_speed = self._io.read_f4le() @property def has_field_exactly_move(self): if hasattr(self, '_m_has_field_exactly_move'): return self._m_has_field_exactly_move self._m_has_field_exactly_move = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_exactly_move', None) @property def has_field_move_dir_type(self): if hasattr(self, '_m_has_field_move_dir_type'): return self._m_has_field_move_dir_type self._m_has_field_move_dir_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_move_dir_type', None) @property def has_field_close_nav_mesh(self): if hasattr(self, '_m_has_field_close_nav_mesh'): return self._m_has_field_close_nav_mesh self._m_has_field_close_nav_mesh = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_close_nav_mesh', None) @property def has_field_direct_move_speed(self): if hasattr(self, '_m_has_field_direct_move_speed'): return self._m_has_field_direct_move_speed self._m_has_field_direct_move_speed = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_direct_move_speed', None) @property def has_field_route_list(self): if hasattr(self, '_m_has_field_route_list'): return self._m_has_field_route_list self._m_has_field_route_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_route_list', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_move_type', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigGuideProjectionGameFinishCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_finish_type: self.finish_type = Output.EnumProjectionGameGuideFinishType(self._io, self, self._root) if self.has_field_param: self.param = self._io.read_f4le() @property def has_field_finish_type(self): if hasattr(self, '_m_has_field_finish_type'): return self._m_has_field_finish_type self._m_has_field_finish_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_finish_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ConfigEntityCommon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_attach_shape: self.effect_attach_shape = Output.DispConfigEffectAttachShape(self._io, self, self._root) if self.has_field_mass: self.mass = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_model_height: self.model_height = self._io.read_f4le() if self.has_field_view_size: self.view_size = self._io.read_f4le() if self.has_field_shadow_view_size_ratio: self.shadow_view_size_ratio = self._io.read_f4le() if self.has_field_override_cull_bounds_radius: self.override_cull_bounds_radius = self._io.read_f4le() if self.has_field_affected_by_world: self.affected_by_world = self._io.read_u1() if self.has_field_check_in_surface: self.check_in_surface = self._io.read_u1() if self.has_field_scale: self.scale = self._io.read_f4le() if self.has_field_disable_tick_distance: self.disable_tick_distance = self._io.read_f4le() if self.has_field_force_pause_tick_distance: self.force_pause_tick_distance = self._io.read_f4le() if self.has_field_should_pause_animator_before_ready: self.should_pause_animator_before_ready = self._io.read_u1() if self.has_field_can_trigger_element_reaction_text: self.can_trigger_element_reaction_text = self._io.read_u1() if self.has_field_use_grass_displacement: self.use_grass_displacement = self._io.read_u1() if self.has_field_mute_element_stick_ui: self.mute_element_stick_ui = self._io.read_u1() if self.has_field_has_after_image: self.has_after_image = self._io.read_u1() if self.has_field_use_dynamic_bone: self.use_dynamic_bone = self._io.read_u1() if self.has_field_enable_crash_damage: self.enable_crash_damage = self._io.read_u1() if self.has_field_clear_animator_on_set_light_deactive: self.clear_animator_on_set_light_deactive = self._io.read_u1() if self.has_field_clear_ai_on_set_light_deactive: self.clear_ai_on_set_light_deactive = self._io.read_u1() if self.has_field_use_final_ik: self.use_final_ik = self._io.read_u1() if self.has_field_element_reaction_scale: self.element_reaction_scale = self._io.read_f4le() if self.has_field_charge_bar_height_offset: self.charge_bar_height_offset = self._io.read_f4le() @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_use_final_ik(self): if hasattr(self, '_m_has_field_use_final_ik'): return self._m_has_field_use_final_ik self._m_has_field_use_final_ik = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_use_final_ik', None) @property def has_field_model_height(self): if hasattr(self, '_m_has_field_model_height'): return self._m_has_field_model_height self._m_has_field_model_height = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_model_height', None) @property def has_field_force_pause_tick_distance(self): if hasattr(self, '_m_has_field_force_pause_tick_distance'): return self._m_has_field_force_pause_tick_distance self._m_has_field_force_pause_tick_distance = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_force_pause_tick_distance', None) @property def has_field_view_size(self): if hasattr(self, '_m_has_field_view_size'): return self._m_has_field_view_size self._m_has_field_view_size = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_view_size', None) @property def has_field_has_after_image(self): if hasattr(self, '_m_has_field_has_after_image'): return self._m_has_field_has_after_image self._m_has_field_has_after_image = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_has_after_image', None) @property def has_field_charge_bar_height_offset(self): if hasattr(self, '_m_has_field_charge_bar_height_offset'): return self._m_has_field_charge_bar_height_offset self._m_has_field_charge_bar_height_offset = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_charge_bar_height_offset', None) @property def has_field_effect_attach_shape(self): if hasattr(self, '_m_has_field_effect_attach_shape'): return self._m_has_field_effect_attach_shape self._m_has_field_effect_attach_shape = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_effect_attach_shape', None) @property def has_field_shadow_view_size_ratio(self): if hasattr(self, '_m_has_field_shadow_view_size_ratio'): return self._m_has_field_shadow_view_size_ratio self._m_has_field_shadow_view_size_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_shadow_view_size_ratio', None) @property def has_field_mass(self): if hasattr(self, '_m_has_field_mass'): return self._m_has_field_mass self._m_has_field_mass = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_mass', None) @property def has_field_can_trigger_element_reaction_text(self): if hasattr(self, '_m_has_field_can_trigger_element_reaction_text'): return self._m_has_field_can_trigger_element_reaction_text self._m_has_field_can_trigger_element_reaction_text = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_can_trigger_element_reaction_text', None) @property def has_field_use_grass_displacement(self): if hasattr(self, '_m_has_field_use_grass_displacement'): return self._m_has_field_use_grass_displacement self._m_has_field_use_grass_displacement = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_use_grass_displacement', None) @property def has_field_clear_ai_on_set_light_deactive(self): if hasattr(self, '_m_has_field_clear_ai_on_set_light_deactive'): return self._m_has_field_clear_ai_on_set_light_deactive self._m_has_field_clear_ai_on_set_light_deactive = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_clear_ai_on_set_light_deactive', None) @property def has_field_mute_element_stick_ui(self): if hasattr(self, '_m_has_field_mute_element_stick_ui'): return self._m_has_field_mute_element_stick_ui self._m_has_field_mute_element_stick_ui = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_mute_element_stick_ui', None) @property def has_field_element_reaction_scale(self): if hasattr(self, '_m_has_field_element_reaction_scale'): return self._m_has_field_element_reaction_scale self._m_has_field_element_reaction_scale = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_element_reaction_scale', None) @property def has_field_override_cull_bounds_radius(self): if hasattr(self, '_m_has_field_override_cull_bounds_radius'): return self._m_has_field_override_cull_bounds_radius self._m_has_field_override_cull_bounds_radius = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_override_cull_bounds_radius', None) @property def has_field_affected_by_world(self): if hasattr(self, '_m_has_field_affected_by_world'): return self._m_has_field_affected_by_world self._m_has_field_affected_by_world = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_affected_by_world', None) @property def has_field_should_pause_animator_before_ready(self): if hasattr(self, '_m_has_field_should_pause_animator_before_ready'): return self._m_has_field_should_pause_animator_before_ready self._m_has_field_should_pause_animator_before_ready = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_should_pause_animator_before_ready', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_use_dynamic_bone(self): if hasattr(self, '_m_has_field_use_dynamic_bone'): return self._m_has_field_use_dynamic_bone self._m_has_field_use_dynamic_bone = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_use_dynamic_bone', None) @property def has_field_enable_crash_damage(self): if hasattr(self, '_m_has_field_enable_crash_damage'): return self._m_has_field_enable_crash_damage self._m_has_field_enable_crash_damage = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_enable_crash_damage', None) @property def has_field_disable_tick_distance(self): if hasattr(self, '_m_has_field_disable_tick_distance'): return self._m_has_field_disable_tick_distance self._m_has_field_disable_tick_distance = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_disable_tick_distance', None) @property def has_field_clear_animator_on_set_light_deactive(self): if hasattr(self, '_m_has_field_clear_animator_on_set_light_deactive'): return self._m_has_field_clear_animator_on_set_light_deactive self._m_has_field_clear_animator_on_set_light_deactive = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_clear_animator_on_set_light_deactive', None) @property def has_field_check_in_surface(self): if hasattr(self, '_m_has_field_check_in_surface'): return self._m_has_field_check_in_surface self._m_has_field_check_in_surface = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_check_in_surface', None) class EnumRogueGadgetStateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueGadgetStateType, self.data.value) return getattr(self, '_m_value', None) class QuestExec(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestExecType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class EnumMapTagType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MapTagType, self.data.value) return getattr(self, '_m_value', None) class EnvAnimalGatherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnviroFollowRotateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_self_rotate_off_set: self.self_rotate_off_set = Output.Vector(self._io, self, self._root) if self.has_field_deactive_on_cutsecne_name: self.deactive_on_cutsecne_name = AuxTypes.String(self._io, self, self._root) @property def has_field_self_rotate_off_set(self): if hasattr(self, '_m_has_field_self_rotate_off_set'): return self._m_has_field_self_rotate_off_set self._m_has_field_self_rotate_off_set = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_self_rotate_off_set', None) @property def has_field_deactive_on_cutsecne_name(self): if hasattr(self, '_m_has_field_deactive_on_cutsecne_name'): return self._m_has_field_deactive_on_cutsecne_name self._m_has_field_deactive_on_cutsecne_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_deactive_on_cutsecne_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfVoiceSoundLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.VoiceSound(self._io, self, self._root)) class ArrayOfEnumSceneTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumSceneType(self._io, self, self._root)) class GrapplingHookMoveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_arrived: self.on_arrived = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_up_force_value: self.up_force_value = self._io.read_f4le() if self.has_field_up_force_time: self.up_force_time = self._io.read_f4le() if self.has_field_arrive_distance: self.arrive_distance = self._io.read_f4le() @property def has_field_up_force_value(self): if hasattr(self, '_m_has_field_up_force_value'): return self._m_has_field_up_force_value self._m_has_field_up_force_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_up_force_value', None) @property def has_field_arrive_distance(self): if hasattr(self, '_m_has_field_arrive_distance'): return self._m_has_field_arrive_distance self._m_has_field_arrive_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_arrive_distance', None) @property def has_field_on_arrived(self): if hasattr(self, '_m_has_field_on_arrived'): return self._m_has_field_on_arrived self._m_has_field_on_arrived = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_arrived', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_up_force_time(self): if hasattr(self, '_m_has_field_up_force_time'): return self._m_has_field_up_force_time self._m_has_field_up_force_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_up_force_time', None) class DictOfAuxTypesVlqBase128LeSConfigAiGroupSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiGroupSurroundData(self._io, self, self._root)) class WinterCampDropGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) class EnumTargetRegisterType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetRegisterType, self.data.value) return getattr(self, '_m_value', None) class ToNearstAnchorPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class HomeWorldPlantExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_seed_id: self.seed_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_id_vec: self.gather_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_home_gather_id: self.home_gather_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bundle_id: self.bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_home_gather: self.config_home_gather = Output.ArrayOfConfigHomeGatherLengthS(self._io, self, self._root) if self.has_field_field_id: self.field_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time: self.time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sprout_time: self.sprout_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_collect_num: self.collect_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sprout_gadget_id: self.sprout_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intee_icon_name: self.intee_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_intee_name: self.intee_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_home_gather_id(self): if hasattr(self, '_m_has_field_home_gather_id'): return self._m_has_field_home_gather_id self._m_has_field_home_gather_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_home_gather_id', None) @property def has_field_sprout_time(self): if hasattr(self, '_m_has_field_sprout_time'): return self._m_has_field_sprout_time self._m_has_field_sprout_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_sprout_time', None) @property def has_field_field_id(self): if hasattr(self, '_m_has_field_field_id'): return self._m_has_field_field_id self._m_has_field_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_field_id', None) @property def has_field_seed_id(self): if hasattr(self, '_m_has_field_seed_id'): return self._m_has_field_seed_id self._m_has_field_seed_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_seed_id', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_collect_num(self): if hasattr(self, '_m_has_field_collect_num'): return self._m_has_field_collect_num self._m_has_field_collect_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_collect_num', None) @property def has_field_bundle_id(self): if hasattr(self, '_m_has_field_bundle_id'): return self._m_has_field_bundle_id self._m_has_field_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_bundle_id', None) @property def has_field_intee_icon_name(self): if hasattr(self, '_m_has_field_intee_icon_name'): return self._m_has_field_intee_icon_name self._m_has_field_intee_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_intee_icon_name', None) @property def has_field_sprout_gadget_id(self): if hasattr(self, '_m_has_field_sprout_gadget_id'): return self._m_has_field_sprout_gadget_id self._m_has_field_sprout_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_sprout_gadget_id', None) @property def has_field_config_home_gather(self): if hasattr(self, '_m_has_field_config_home_gather'): return self._m_has_field_config_home_gather self._m_has_field_config_home_gather = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_config_home_gather', None) @property def has_field_gather_id_vec(self): if hasattr(self, '_m_has_field_gather_id_vec'): return self._m_has_field_gather_id_vec self._m_has_field_gather_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gather_id_vec', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_time', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_intee_name(self): if hasattr(self, '_m_has_field_intee_name'): return self._m_has_field_intee_name self._m_has_field_intee_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_intee_name', None) class ConfigAudioDialog(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_reactions: self.reactions = Output.ArrayOfAudioDialogReactionLengthU(self._io, self, self._root) @property def has_field_reactions(self): if hasattr(self, '_m_has_field_reactions'): return self._m_has_field_reactions self._m_has_field_reactions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reactions', None) class ArrayOfReputationEntranceCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ReputationEntranceCond(self._io, self, self._root)) class ChangeFollowDampTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_position_damp_time: self.position_damp_time = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_rotation_damp_time: self.rotation_damp_time = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_position_damp_time(self): if hasattr(self, '_m_has_field_position_damp_time'): return self._m_has_field_position_damp_time self._m_has_field_position_damp_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_position_damp_time', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_rotation_damp_time(self): if hasattr(self, '_m_has_field_rotation_damp_time'): return self._m_has_field_rotation_damp_time self._m_has_field_rotation_damp_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_rotation_damp_time', None) class RandomQuestElemPoolExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sample_list: self.sample_list = Output.ArrayOfQuestElemSampleLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pool_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_sample_list(self): if hasattr(self, '_m_has_field_sample_list'): return self._m_has_field_sample_list self._m_has_field_sample_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sample_list', None) class ConfigAudioArea2dAmbience(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_name: self.area_name = AuxTypes.String(self._io, self, self._root) if self.has_field_area_points: self.area_points = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_y_zero_anchor: self.y_zero_anchor = self._io.read_f4le() if self.has_field_area_group_name: self.area_group_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enable_height_check: self.enable_height_check = self._io.read_u1() if self.has_field_top: self.top = self._io.read_f4le() if self.has_field_bottom: self.bottom = self._io.read_f4le() if self.has_field_is_ambience: self.is_ambience = self._io.read_u1() if self.has_field_enter_events: self.enter_events = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_leave_events: self.leave_events = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_is_reverb: self.is_reverb = self._io.read_u1() if self.has_field_aux_bus_name: self.aux_bus_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_exclude_other: self.exclude_other = self._io.read_u1() if self.has_field_enable_change_states: self.enable_change_states = self._io.read_u1() if self.has_field_enter_states: self.enter_states = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) if self.has_field_leave_states: self.leave_states = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) @property def has_field_is_ambience(self): if hasattr(self, '_m_has_field_is_ambience'): return self._m_has_field_is_ambience self._m_has_field_is_ambience = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_is_ambience', None) @property def has_field_bottom(self): if hasattr(self, '_m_has_field_bottom'): return self._m_has_field_bottom self._m_has_field_bottom = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_bottom', None) @property def has_field_exclude_other(self): if hasattr(self, '_m_has_field_exclude_other'): return self._m_has_field_exclude_other self._m_has_field_exclude_other = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_exclude_other', None) @property def has_field_leave_events(self): if hasattr(self, '_m_has_field_leave_events'): return self._m_has_field_leave_events self._m_has_field_leave_events = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_leave_events', None) @property def has_field_enable_height_check(self): if hasattr(self, '_m_has_field_enable_height_check'): return self._m_has_field_enable_height_check self._m_has_field_enable_height_check = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_enable_height_check', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_enter_events(self): if hasattr(self, '_m_has_field_enter_events'): return self._m_has_field_enter_events self._m_has_field_enter_events = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enter_events', None) @property def has_field_leave_states(self): if hasattr(self, '_m_has_field_leave_states'): return self._m_has_field_leave_states self._m_has_field_leave_states = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_leave_states', None) @property def has_field_y_zero_anchor(self): if hasattr(self, '_m_has_field_y_zero_anchor'): return self._m_has_field_y_zero_anchor self._m_has_field_y_zero_anchor = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_y_zero_anchor', None) @property def has_field_is_reverb(self): if hasattr(self, '_m_has_field_is_reverb'): return self._m_has_field_is_reverb self._m_has_field_is_reverb = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_is_reverb', None) @property def has_field_area_points(self): if hasattr(self, '_m_has_field_area_points'): return self._m_has_field_area_points self._m_has_field_area_points = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_area_points', None) @property def has_field_top(self): if hasattr(self, '_m_has_field_top'): return self._m_has_field_top self._m_has_field_top = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_top', None) @property def has_field_enable_change_states(self): if hasattr(self, '_m_has_field_enable_change_states'): return self._m_has_field_enable_change_states self._m_has_field_enable_change_states = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_enable_change_states', None) @property def has_field_area_group_name(self): if hasattr(self, '_m_has_field_area_group_name'): return self._m_has_field_area_group_name self._m_has_field_area_group_name = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_area_group_name', None) @property def has_field_area_name(self): if hasattr(self, '_m_has_field_area_name'): return self._m_has_field_area_name self._m_has_field_area_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_area_name', None) @property def has_field_enter_states(self): if hasattr(self, '_m_has_field_enter_states'): return self._m_has_field_enter_states self._m_has_field_enter_states = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_enter_states', None) @property def has_field_aux_bus_name(self): if hasattr(self, '_m_has_field_aux_bus_name'): return self._m_has_field_aux_bus_name self._m_has_field_aux_bus_name = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_aux_bus_name', None) class SceneVehicleSummonPointMapMarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChessCardEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardEffectType, self.data.value) return getattr(self, '_m_value', None) class BlossomShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMoveAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_start_event: self.start_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_stop_event: self.stop_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_move_state_param: self.move_state_param = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_fall_on_ground_event: self.fall_on_ground_event = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_start_event(self): if hasattr(self, '_m_has_field_start_event'): return self._m_has_field_start_event self._m_has_field_start_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start_event', None) @property def has_field_stop_event(self): if hasattr(self, '_m_has_field_stop_event'): return self._m_has_field_stop_event self._m_has_field_stop_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stop_event', None) @property def has_field_move_state_param(self): if hasattr(self, '_m_has_field_move_state_param'): return self._m_has_field_move_state_param self._m_has_field_move_state_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_move_state_param', None) @property def has_field_fall_on_ground_event(self): if hasattr(self, '_m_has_field_fall_on_ground_event'): return self._m_has_field_fall_on_ground_event self._m_has_field_fall_on_ground_event = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fall_on_ground_event', None) class ArrayOfConfigGadgetUiExtraItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetUiExtraItem(self._io, self, self._root)) class QteExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_step_id: self.start_step_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_qte_type: self.qte_type = Output.EnumQteType(self._io, self, self._root) if self.has_field_start_exec: self.start_exec = Output.ArrayOfQteExecLengthS(self._io, self, self._root) if self.has_field_success_exec: self.success_exec = Output.ArrayOfQteExecLengthS(self._io, self, self._root) if self.has_field_fail_exec: self.fail_exec = Output.ArrayOfQteExecLengthS(self._io, self, self._root) @property def has_field_start_exec(self): if hasattr(self, '_m_has_field_start_exec'): return self._m_has_field_start_exec self._m_has_field_start_exec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_start_exec', None) @property def has_field_qte_type(self): if hasattr(self, '_m_has_field_qte_type'): return self._m_has_field_qte_type self._m_has_field_qte_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_qte_type', None) @property def has_field_success_exec(self): if hasattr(self, '_m_has_field_success_exec'): return self._m_has_field_success_exec self._m_has_field_success_exec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_success_exec', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_start_step_id(self): if hasattr(self, '_m_has_field_start_step_id'): return self._m_has_field_start_step_id self._m_has_field_start_step_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_start_step_id', None) @property def has_field_fail_exec(self): if hasattr(self, '_m_has_field_fail_exec'): return self._m_has_field_fail_exec self._m_has_field_fail_exec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fail_exec', None) class FireUiEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_slot: self.effect_slot = Output.EnumActionPanelEffectSlot(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_effect_slot(self): if hasattr(self, '_m_has_field_effect_slot'): return self._m_has_field_effect_slot self._m_has_field_effect_slot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_slot', None) class EnumLookAtTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LookAtTargetType, self.data.value) return getattr(self, '_m_value', None) class DungeonSerialConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_take_num: self.max_take_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_take_cost: self.take_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_max_take_num(self): if hasattr(self, '_m_has_field_max_take_num'): return self._m_has_field_max_take_num self._m_has_field_max_take_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_max_take_num', None) @property def has_field_take_cost(self): if hasattr(self, '_m_has_field_take_cost'): return self._m_has_field_take_cost self._m_has_field_take_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_take_cost', None) class PsActivitiesCategoryTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEffectAttachShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestFishTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusic(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_switch_group: self.switch_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_play_event: self.play_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_stop_event: self.stop_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_pause_event: self.pause_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_resume_event: self.resume_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_duck_event: self.duck_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_unduck_event: self.unduck_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_start_transitions: self.start_transitions = Output.ConfigMusicTransitions(self._io, self, self._root) if self.has_field_sync_transitions: self.sync_transitions = Output.ConfigMusicSyncTransitions(self._io, self, self._root) if self.has_field_time_transitions: self.time_transitions = Output.ConfigMusicTimeTransitions(self._io, self, self._root) if self.has_field_stimulus_handlers: self.stimulus_handlers = Output.ArrayOfDispConfigMusicStimulusHandlerLengthU(self._io, self, self._root) @property def has_field_unduck_event(self): if hasattr(self, '_m_has_field_unduck_event'): return self._m_has_field_unduck_event self._m_has_field_unduck_event = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_unduck_event', None) @property def has_field_sync_transitions(self): if hasattr(self, '_m_has_field_sync_transitions'): return self._m_has_field_sync_transitions self._m_has_field_sync_transitions = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_sync_transitions', None) @property def has_field_stimulus_handlers(self): if hasattr(self, '_m_has_field_stimulus_handlers'): return self._m_has_field_stimulus_handlers self._m_has_field_stimulus_handlers = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_stimulus_handlers', None) @property def has_field_stop_event(self): if hasattr(self, '_m_has_field_stop_event'): return self._m_has_field_stop_event self._m_has_field_stop_event = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_stop_event', None) @property def has_field_duck_event(self): if hasattr(self, '_m_has_field_duck_event'): return self._m_has_field_duck_event self._m_has_field_duck_event = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_duck_event', None) @property def has_field_play_event(self): if hasattr(self, '_m_has_field_play_event'): return self._m_has_field_play_event self._m_has_field_play_event = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_play_event', None) @property def has_field_time_transitions(self): if hasattr(self, '_m_has_field_time_transitions'): return self._m_has_field_time_transitions self._m_has_field_time_transitions = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_time_transitions', None) @property def has_field_switch_group(self): if hasattr(self, '_m_has_field_switch_group'): return self._m_has_field_switch_group self._m_has_field_switch_group = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_switch_group', None) @property def has_field_start_transitions(self): if hasattr(self, '_m_has_field_start_transitions'): return self._m_has_field_start_transitions self._m_has_field_start_transitions = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_start_transitions', None) @property def has_field_pause_event(self): if hasattr(self, '_m_has_field_pause_event'): return self._m_has_field_pause_event self._m_has_field_pause_event = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_pause_event', None) @property def has_field_resume_event(self): if hasattr(self, '_m_has_field_resume_event'): return self._m_has_field_resume_event self._m_has_field_resume_event = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_resume_event', None) class DynamicCollisionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tags: self.tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_checker: self.is_checker = self._io.read_u1() @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tags', None) @property def has_field_is_checker(self): if hasattr(self, '_m_has_field_is_checker'): return self._m_has_field_is_checker self._m_has_field_is_checker = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_checker', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class LanV2fireworksSkillDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_type: self.skill_type = Output.EnumFireworksReformSkillType(self._io, self, self._root) if self.has_field_stamina_value_cost: self.stamina_value_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_challenge_id: self.unlock_challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delta_fire_element_value: self.delta_fire_element_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_lucky_prob: self.lucky_prob = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_factor_add_value_min: self.factor_add_value_min = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_factor_add_value_max: self.factor_add_value_max = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_params: self.effect_params = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_skill_title: self.skill_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_desc: self.skill_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_args: self.desc_args = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_factor_add_value_min(self): if hasattr(self, '_m_has_field_factor_add_value_min'): return self._m_has_field_factor_add_value_min self._m_has_field_factor_add_value_min = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_factor_add_value_min', None) @property def has_field_skill_title(self): if hasattr(self, '_m_has_field_skill_title'): return self._m_has_field_skill_title self._m_has_field_skill_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_skill_title', None) @property def has_field_delta_fire_element_value(self): if hasattr(self, '_m_has_field_delta_fire_element_value'): return self._m_has_field_delta_fire_element_value self._m_has_field_delta_fire_element_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_delta_fire_element_value', None) @property def has_field_unlock_challenge_id(self): if hasattr(self, '_m_has_field_unlock_challenge_id'): return self._m_has_field_unlock_challenge_id self._m_has_field_unlock_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_challenge_id', None) @property def has_field_skill_desc(self): if hasattr(self, '_m_has_field_skill_desc'): return self._m_has_field_skill_desc self._m_has_field_skill_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_skill_desc', None) @property def has_field_skill_type(self): if hasattr(self, '_m_has_field_skill_type'): return self._m_has_field_skill_type self._m_has_field_skill_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_type', None) @property def has_field_effect_params(self): if hasattr(self, '_m_has_field_effect_params'): return self._m_has_field_effect_params self._m_has_field_effect_params = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_effect_params', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_skill_id', None) @property def has_field_stamina_value_cost(self): if hasattr(self, '_m_has_field_stamina_value_cost'): return self._m_has_field_stamina_value_cost self._m_has_field_stamina_value_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stamina_value_cost', None) @property def has_field_factor_add_value_max(self): if hasattr(self, '_m_has_field_factor_add_value_max'): return self._m_has_field_factor_add_value_max self._m_has_field_factor_add_value_max = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_factor_add_value_max', None) @property def has_field_lucky_prob(self): if hasattr(self, '_m_has_field_lucky_prob'): return self._m_has_field_lucky_prob self._m_has_field_lucky_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_lucky_prob', None) @property def has_field_desc_args(self): if hasattr(self, '_m_has_field_desc_args'): return self._m_has_field_desc_args self._m_has_field_desc_args = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_desc_args', None) class BargainExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dialog_id: self.dialog_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_expected_value: self.expected_value = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_space: self.space = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_talk_id: self.success_talk_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_fail_talk_id: self.fail_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mood_npc_id: self.mood_npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mood_upper_limit: self.mood_upper_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_random_mood: self.random_mood = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mood_alert_limit: self.mood_alert_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mood_low_limit: self.mood_low_limit = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_mood_low_limit_text: self.mood_low_limit_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_fail_mood_deduction: self.single_fail_mood_deduction = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_fail_talk_id: self.single_fail_talk_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_delete_item: self.delete_item = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_text: self.title_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_afford_text: self.afford_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_storage_text: self.storage_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mood_hint_text: self.mood_hint_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mood_desc_text: self.mood_desc_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_delete_item(self): if hasattr(self, '_m_has_field_delete_item'): return self._m_has_field_delete_item self._m_has_field_delete_item = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_delete_item', None) @property def has_field_afford_text(self): if hasattr(self, '_m_has_field_afford_text'): return self._m_has_field_afford_text self._m_has_field_afford_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_afford_text', None) @property def has_field_expected_value(self): if hasattr(self, '_m_has_field_expected_value'): return self._m_has_field_expected_value self._m_has_field_expected_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_expected_value', None) @property def has_field_mood_hint_text(self): if hasattr(self, '_m_has_field_mood_hint_text'): return self._m_has_field_mood_hint_text self._m_has_field_mood_hint_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_mood_hint_text', None) @property def has_field_success_talk_id(self): if hasattr(self, '_m_has_field_success_talk_id'): return self._m_has_field_success_talk_id self._m_has_field_success_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_success_talk_id', None) @property def has_field_storage_text(self): if hasattr(self, '_m_has_field_storage_text'): return self._m_has_field_storage_text self._m_has_field_storage_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_storage_text', None) @property def has_field_single_fail_mood_deduction(self): if hasattr(self, '_m_has_field_single_fail_mood_deduction'): return self._m_has_field_single_fail_mood_deduction self._m_has_field_single_fail_mood_deduction = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_single_fail_mood_deduction', None) @property def has_field_space(self): if hasattr(self, '_m_has_field_space'): return self._m_has_field_space self._m_has_field_space = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_space', None) @property def has_field_mood_desc_text(self): if hasattr(self, '_m_has_field_mood_desc_text'): return self._m_has_field_mood_desc_text self._m_has_field_mood_desc_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_mood_desc_text', None) @property def has_field_mood_upper_limit(self): if hasattr(self, '_m_has_field_mood_upper_limit'): return self._m_has_field_mood_upper_limit self._m_has_field_mood_upper_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_mood_upper_limit', None) @property def has_field_mood_npc_id(self): if hasattr(self, '_m_has_field_mood_npc_id'): return self._m_has_field_mood_npc_id self._m_has_field_mood_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mood_npc_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_single_fail_talk_id(self): if hasattr(self, '_m_has_field_single_fail_talk_id'): return self._m_has_field_single_fail_talk_id self._m_has_field_single_fail_talk_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_single_fail_talk_id', None) @property def has_field_mood_alert_limit(self): if hasattr(self, '_m_has_field_mood_alert_limit'): return self._m_has_field_mood_alert_limit self._m_has_field_mood_alert_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_mood_alert_limit', None) @property def has_field_title_text(self): if hasattr(self, '_m_has_field_title_text'): return self._m_has_field_title_text self._m_has_field_title_text = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_title_text', None) @property def has_field_mood_low_limit(self): if hasattr(self, '_m_has_field_mood_low_limit'): return self._m_has_field_mood_low_limit self._m_has_field_mood_low_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_mood_low_limit', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_fail_talk_id(self): if hasattr(self, '_m_has_field_fail_talk_id'): return self._m_has_field_fail_talk_id self._m_has_field_fail_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_fail_talk_id', None) @property def has_field_random_mood(self): if hasattr(self, '_m_has_field_random_mood'): return self._m_has_field_random_mood self._m_has_field_random_mood = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_random_mood', None) @property def has_field_mood_low_limit_text(self): if hasattr(self, '_m_has_field_mood_low_limit_text'): return self._m_has_field_mood_low_limit_text self._m_has_field_mood_low_limit_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_mood_low_limit_text', None) class EnumGuideLevelType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideLevelType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trigger_enter_action_list: self.trigger_enter_action_list = Output.ArrayOfDispConfigGadgetStateActionLengthU(self._io, self, self._root) if self.has_field_gadget_state_action_list: self.gadget_state_action_list = Output.ArrayOfDispConfigGadgetStateActionLengthU(self._io, self, self._root) if self.has_field_platform_action_list: self.platform_action_list = Output.ArrayOfDispConfigGadgetStateActionLengthU(self._io, self, self._root) if self.has_field_interact_action_list: self.interact_action_list = Output.ArrayOfDispConfigGadgetStateActionLengthU(self._io, self, self._root) if self.has_field_post_ui_interact_action_list: self.post_ui_interact_action_list = Output.ArrayOfDispConfigGadgetStateActionLengthU(self._io, self, self._root) @property def has_field_trigger_enter_action_list(self): if hasattr(self, '_m_has_field_trigger_enter_action_list'): return self._m_has_field_trigger_enter_action_list self._m_has_field_trigger_enter_action_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_enter_action_list', None) @property def has_field_platform_action_list(self): if hasattr(self, '_m_has_field_platform_action_list'): return self._m_has_field_platform_action_list self._m_has_field_platform_action_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_platform_action_list', None) @property def has_field_gadget_state_action_list(self): if hasattr(self, '_m_has_field_gadget_state_action_list'): return self._m_has_field_gadget_state_action_list self._m_has_field_gadget_state_action_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadget_state_action_list', None) @property def has_field_interact_action_list(self): if hasattr(self, '_m_has_field_interact_action_list'): return self._m_has_field_interact_action_list self._m_has_field_interact_action_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_interact_action_list', None) @property def has_field_post_ui_interact_action_list(self): if hasattr(self, '_m_has_field_post_ui_interact_action_list'): return self._m_has_field_post_ui_interact_action_list self._m_has_field_post_ui_interact_action_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_post_ui_interact_action_list', None) class ConfigCoopEndNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCoopBaseNode(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_save_point_id: self.save_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_save_point_id(self): if hasattr(self, '_m_has_field_save_point_id'): return self._m_has_field_save_point_id self._m_has_field_save_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_save_point_id', None) @property def coop_node_id(self): if hasattr(self, '_m_coop_node_id'): return self._m_coop_node_id self._m_coop_node_id = self.base.coop_node_id return getattr(self, '_m_coop_node_id', None) @property def coop_node_type(self): if hasattr(self, '_m_coop_node_type'): return self._m_coop_node_type self._m_coop_node_type = self.base.coop_node_type return getattr(self, '_m_coop_node_type', None) @property def next_node_array(self): if hasattr(self, '_m_next_node_array'): return self._m_next_node_array self._m_next_node_array = self.base.next_node_array return getattr(self, '_m_next_node_array', None) class DictOfAuxTypesVlqBase128LeSConfigAiFindBackData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFindBackData(self._io, self, self._root)) class InvestigationMonsterMapMarkCreateCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_condition_type: self.condition_type = Output.EnumInvestigationMonsterMapMarkCreateConditionType(self._io, self, self._root) if self.has_field_condition_param: self.condition_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_condition_type(self): if hasattr(self, '_m_has_field_condition_type'): return self._m_has_field_condition_type self._m_has_field_condition_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_condition_type', None) @property def has_field_condition_param(self): if hasattr(self, '_m_has_field_condition_param'): return self._m_has_field_condition_param self._m_has_field_condition_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_condition_param', None) class ConfigAttachment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_slot_name: self.slot_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_path: self.attach_path = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_path: self.effect_path = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_pos: self.attach_pos = Output.Vector(self._io, self, self._root) if self.has_field_attach_rot: self.attach_rot = Output.Vector(self._io, self, self._root) if self.has_field_attach_scale: self.attach_scale = Output.Vector(self._io, self, self._root) @property def has_field_attach_pos(self): if hasattr(self, '_m_has_field_attach_pos'): return self._m_has_field_attach_pos self._m_has_field_attach_pos = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_attach_pos', None) @property def has_field_attach_scale(self): if hasattr(self, '_m_has_field_attach_scale'): return self._m_has_field_attach_scale self._m_has_field_attach_scale = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_attach_scale', None) @property def has_field_attach_rot(self): if hasattr(self, '_m_has_field_attach_rot'): return self._m_has_field_attach_rot self._m_has_field_attach_rot = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_attach_rot', None) @property def has_field_effect_path(self): if hasattr(self, '_m_has_field_effect_path'): return self._m_has_field_effect_path self._m_has_field_effect_path = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_effect_path', None) @property def has_field_attach_path(self): if hasattr(self, '_m_has_field_attach_path'): return self._m_has_field_attach_path self._m_has_field_attach_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_path', None) @property def has_field_slot_name(self): if hasattr(self, '_m_has_field_slot_name'): return self._m_has_field_slot_name self._m_has_field_slot_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_slot_name', None) class ConfigAttackBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSimpleAttackPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_size: self.size = Output.DynamicFloatVector(self._io, self, self._root) if self.has_field_mute_hit_behind_scene: self.mute_hit_behind_scene = self._io.read_u1() @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def use_custom_shape(self): if hasattr(self, '_m_use_custom_shape'): return self._m_use_custom_shape self._m_use_custom_shape = self.base.use_custom_shape return getattr(self, '_m_use_custom_shape', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def has_field_mute_hit_behind_scene(self): if hasattr(self, '_m_has_field_mute_hit_behind_scene'): return self._m_has_field_mute_hit_behind_scene self._m_has_field_mute_hit_behind_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mute_hit_behind_scene', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_size', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class ArrayOfMaterialFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MaterialFloat(self._io, self, self._root)) class CityConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id_vec: self.area_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_city_name: self.city_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_pos_x: self.map_pos_x = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_map_pos_y: self.map_pos_y = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_zoom_for_exploration: self.zoom_for_exploration = self._io.read_f4le() if self.has_field_adventure_point_id: self.adventure_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_expedition_map: self.expedition_map = AuxTypes.String(self._io, self, self._root) if self.has_field_expedition_water_mark: self.expedition_water_mark = AuxTypes.String(self._io, self, self._root) if self.has_field_open_state: self.open_state = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_city_goddness_name: self.city_goddness_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_goddness_desc: self.city_goddness_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_expedition_map(self): if hasattr(self, '_m_has_field_expedition_map'): return self._m_has_field_expedition_map self._m_has_field_expedition_map = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_expedition_map', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_city_goddness_desc(self): if hasattr(self, '_m_has_field_city_goddness_desc'): return self._m_has_field_city_goddness_desc self._m_has_field_city_goddness_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_city_goddness_desc', None) @property def has_field_map_pos_x(self): if hasattr(self, '_m_has_field_map_pos_x'): return self._m_has_field_map_pos_x self._m_has_field_map_pos_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_map_pos_x', None) @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_open_state', None) @property def has_field_expedition_water_mark(self): if hasattr(self, '_m_has_field_expedition_water_mark'): return self._m_has_field_expedition_water_mark self._m_has_field_expedition_water_mark = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_expedition_water_mark', None) @property def has_field_city_goddness_name(self): if hasattr(self, '_m_has_field_city_goddness_name'): return self._m_has_field_city_goddness_name self._m_has_field_city_goddness_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_city_goddness_name', None) @property def has_field_area_id_vec(self): if hasattr(self, '_m_has_field_area_id_vec'): return self._m_has_field_area_id_vec self._m_has_field_area_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_area_id_vec', None) @property def has_field_city_name(self): if hasattr(self, '_m_has_field_city_name'): return self._m_has_field_city_name self._m_has_field_city_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_city_name', None) @property def has_field_map_pos_y(self): if hasattr(self, '_m_has_field_map_pos_y'): return self._m_has_field_map_pos_y self._m_has_field_map_pos_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_map_pos_y', None) @property def has_field_zoom_for_exploration(self): if hasattr(self, '_m_has_field_zoom_for_exploration'): return self._m_has_field_zoom_for_exploration self._m_has_field_zoom_for_exploration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_zoom_for_exploration', None) @property def has_field_adventure_point_id(self): if hasattr(self, '_m_has_field_adventure_point_id'): return self._m_has_field_adventure_point_id self._m_has_field_adventure_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_adventure_point_id', None) class DynamicFloatVector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_x: self.x = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_y: self.y = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_z: self.z = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_x(self): if hasattr(self, '_m_has_field_x'): return self._m_has_field_x self._m_has_field_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_x', None) @property def has_field_y(self): if hasattr(self, '_m_has_field_y'): return self._m_has_field_y self._m_has_field_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y', None) @property def has_field_z(self): if hasattr(self, '_m_has_field_z'): return self._m_has_field_z self._m_has_field_z = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_z', None) class ArrayOfTriggerToStatesLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TriggerToStates(self._io, self, self._root)) class MaterialCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumMaterialCodexType(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() if self.has_field_show_only_unlocked: self.show_only_unlocked = self._io.read_u1() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_show_only_unlocked(self): if hasattr(self, '_m_has_field_show_only_unlocked'): return self._m_has_field_show_only_unlocked self._m_has_field_show_only_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_show_only_unlocked', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigTile(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tile_name: self.tile_name = AuxTypes.String(self._io, self, self._root) if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_type: self.special_type = Output.EnumTileSpecialType(self._io, self, self._root) if self.has_field_fixed_y: self.fixed_y = self._io.read_f4le() if self.has_field_pool_size: self.pool_size = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_initial_elements: self.initial_elements = Output.ArrayOfConfigTileElementLengthU(self._io, self, self._root) if self.has_field_basic_action: self.basic_action = Output.ConfigMassiveElementTriggerAction(self._io, self, self._root) if self.has_field_field_map_material: self.field_map_material = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_material: self.effect_material = AuxTypes.String(self._io, self, self._root) @property def has_field_tile_name(self): if hasattr(self, '_m_has_field_tile_name'): return self._m_has_field_tile_name self._m_has_field_tile_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_tile_name', None) @property def has_field_initial_elements(self): if hasattr(self, '_m_has_field_initial_elements'): return self._m_has_field_initial_elements self._m_has_field_initial_elements = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_initial_elements', None) @property def has_field_fixed_y(self): if hasattr(self, '_m_has_field_fixed_y'): return self._m_has_field_fixed_y self._m_has_field_fixed_y = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_fixed_y', None) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_camp_id', None) @property def has_field_special_type(self): if hasattr(self, '_m_has_field_special_type'): return self._m_has_field_special_type self._m_has_field_special_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_special_type', None) @property def has_field_effect_material(self): if hasattr(self, '_m_has_field_effect_material'): return self._m_has_field_effect_material self._m_has_field_effect_material = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_effect_material', None) @property def has_field_field_map_material(self): if hasattr(self, '_m_has_field_field_map_material'): return self._m_has_field_field_map_material self._m_has_field_field_map_material = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_field_map_material', None) @property def has_field_pool_size(self): if hasattr(self, '_m_has_field_pool_size'): return self._m_has_field_pool_size self._m_has_field_pool_size = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_pool_size', None) @property def has_field_basic_action(self): if hasattr(self, '_m_has_field_basic_action'): return self._m_has_field_basic_action self._m_has_field_basic_action = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_basic_action', None) class ShopSpecialKeysDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_goods_id: self.goods_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_limit: self.single_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_goods_id(self): if hasattr(self, '_m_has_field_goods_id'): return self._m_has_field_goods_id self._m_has_field_goods_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_goods_id', None) @property def has_field_single_limit(self): if hasattr(self, '_m_has_field_single_limit'): return self._m_has_field_single_limit self._m_has_field_single_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_single_limit', None) class EnumTriggerWeatherType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TriggerWeatherType, self.data.value) return getattr(self, '_m_value', None) class CircleDetectDirectionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumActionTokenSourceTypeDictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumActionTokenSourceTypeDictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root)) class RogueSequenceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sequence_id: self.sequence_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cell_list: self.cell_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cell_priority: self.cell_priority = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_cell_seq_list: self.cell_seq_list = Output.ArrayOfRogueSequenceCellConfigLengthS(self._io, self, self._root) @property def has_field_cell_priority(self): if hasattr(self, '_m_has_field_cell_priority'): return self._m_has_field_cell_priority self._m_has_field_cell_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cell_priority', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_cell_seq_list(self): if hasattr(self, '_m_has_field_cell_seq_list'): return self._m_has_field_cell_seq_list self._m_has_field_cell_seq_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cell_seq_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sequence_id(self): if hasattr(self, '_m_has_field_sequence_id'): return self._m_has_field_sequence_id self._m_has_field_sequence_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sequence_id', None) @property def has_field_cell_list(self): if hasattr(self, '_m_has_field_cell_list'): return self._m_has_field_cell_list self._m_has_field_cell_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cell_list', None) class EnumSwitchSkillPriority(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SwitchSkillPriority, self.data.value) return getattr(self, '_m_value', None) class EnumWidgetInfoPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetInfoPos, self.data.value) return getattr(self, '_m_value', None) class ExcludeGravityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ActivitySkillTargetComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabLoopDungeonRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReputationExploreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideTriggerExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_guide_name: self.guide_name = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGuideTriggerType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_state: self.open_state = Output.EnumOpenStateType(self._io, self, self._root) @property def has_field_guide_name(self): if hasattr(self, '_m_has_field_guide_name'): return self._m_has_field_guide_name self._m_has_field_guide_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_guide_name', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_state', None) class ActivitySummerTimeRaceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarCostumeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_skin_id: self.skin_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_index_id: self.index_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_character_id: self.character_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_prefab_remote_path_hash: self.prefab_remote_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_remote_path_hash: self.prefab_remote_path_hash_pre = self._io.read_s1() if self.has_field_prefab_npc_path_hash: self.prefab_npc_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_npc_path_hash: self.prefab_npc_path_hash_pre = self._io.read_s1() if self.has_field_animator_config_path_hash: self.animator_config_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_animator_config_path_hash: self.animator_config_path_hash_pre = self._io.read_s1() if self.has_field_prefab_manekin_path_hash: self.prefab_manekin_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_manekin_path_hash: self.prefab_manekin_path_hash_pre = self._io.read_s1() if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_pre = self._io.read_s1() if self.has_field_controller_remote_path_hash: self.controller_remote_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_remote_path_hash: self.controller_remote_path_hash_pre = self._io.read_s1() if self.has_field_is_default: self.is_default = self._io.read_u1() if self.has_field_is_default_unlock: self.is_default_unlock = self._io.read_u1() if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hide: self.hide = self._io.read_u1() if self.has_field_front_icon_name: self.front_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_side_icon_name: self.side_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_image_name_hash: self.image_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_image_name_hash: self.image_name_hash_pre = self._io.read_s1() if self.has_field_domestic_hide_in_art_preview: self.domestic_hide_in_art_preview = self._io.read_u1() if self.has_field_oversea_hide_in_art_preview: self.oversea_hide_in_art_preview = self._io.read_u1() @property def has_field_image_name_hash(self): if hasattr(self, '_m_has_field_image_name_hash'): return self._m_has_field_image_name_hash self._m_has_field_image_name_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_image_name_hash', None) @property def has_field_is_default(self): if hasattr(self, '_m_has_field_is_default'): return self._m_has_field_is_default self._m_has_field_is_default = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_is_default', None) @property def has_field_controller_remote_path_hash(self): if hasattr(self, '_m_has_field_controller_remote_path_hash'): return self._m_has_field_controller_remote_path_hash self._m_has_field_controller_remote_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_controller_remote_path_hash', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_skin_id(self): if hasattr(self, '_m_has_field_skin_id'): return self._m_has_field_skin_id self._m_has_field_skin_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_skin_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_front_icon_name(self): if hasattr(self, '_m_has_field_front_icon_name'): return self._m_has_field_front_icon_name self._m_has_field_front_icon_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_front_icon_name', None) @property def has_field_index_id(self): if hasattr(self, '_m_has_field_index_id'): return self._m_has_field_index_id self._m_has_field_index_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_index_id', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_quality', None) @property def has_field_is_default_unlock(self): if hasattr(self, '_m_has_field_is_default_unlock'): return self._m_has_field_is_default_unlock self._m_has_field_is_default_unlock = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_default_unlock', None) @property def has_field_prefab_manekin_path_hash(self): if hasattr(self, '_m_has_field_prefab_manekin_path_hash'): return self._m_has_field_prefab_manekin_path_hash self._m_has_field_prefab_manekin_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_prefab_manekin_path_hash', None) @property def has_field_hide(self): if hasattr(self, '_m_has_field_hide'): return self._m_has_field_hide self._m_has_field_hide = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_hide', None) @property def has_field_prefab_remote_path_hash(self): if hasattr(self, '_m_has_field_prefab_remote_path_hash'): return self._m_has_field_prefab_remote_path_hash self._m_has_field_prefab_remote_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_prefab_remote_path_hash', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_side_icon_name(self): if hasattr(self, '_m_has_field_side_icon_name'): return self._m_has_field_side_icon_name self._m_has_field_side_icon_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_side_icon_name', None) @property def has_field_domestic_hide_in_art_preview(self): if hasattr(self, '_m_has_field_domestic_hide_in_art_preview'): return self._m_has_field_domestic_hide_in_art_preview self._m_has_field_domestic_hide_in_art_preview = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_domestic_hide_in_art_preview', None) @property def has_field_prefab_npc_path_hash(self): if hasattr(self, '_m_has_field_prefab_npc_path_hash'): return self._m_has_field_prefab_npc_path_hash self._m_has_field_prefab_npc_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_prefab_npc_path_hash', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_character_id(self): if hasattr(self, '_m_has_field_character_id'): return self._m_has_field_character_id self._m_has_field_character_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_character_id', None) @property def has_field_animator_config_path_hash(self): if hasattr(self, '_m_has_field_animator_config_path_hash'): return self._m_has_field_animator_config_path_hash self._m_has_field_animator_config_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_animator_config_path_hash', None) @property def has_field_oversea_hide_in_art_preview(self): if hasattr(self, '_m_has_field_oversea_hide_in_art_preview'): return self._m_has_field_oversea_hide_in_art_preview self._m_has_field_oversea_hide_in_art_preview = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_oversea_hide_in_art_preview', None) class ConfigControlPart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_angular_speed: self.angular_speed = self._io.read_f4le() if self.has_field_part_root_name: self.part_root_name = AuxTypes.String(self._io, self, self._root) if self.has_field_forward_by: self.forward_by = Output.EnumControlPartForwardBy(self._io, self, self._root) if self.has_field_forward_axial_fix: self.forward_axial_fix = Output.Vector(self._io, self, self._root) if self.has_field_rotate_by: self.rotate_by = Output.EnumControlPartRotateBy(self._io, self, self._root) if self.has_field_do_on_un_eabled: self.do_on_un_eabled = Output.EnumControlPartDoOnUnEnabled(self._io, self, self._root) if self.has_field_forward_by_trans_name: self.forward_by_trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_limit_horizontal: self.limit_horizontal = self._io.read_f4le() if self.has_field_limit_vertical: self.limit_vertical = self._io.read_f4le() if self.has_field_target_type: self.target_type = Output.EnumControlPartTargetType(self._io, self, self._root) @property def has_field_do_on_un_eabled(self): if hasattr(self, '_m_has_field_do_on_un_eabled'): return self._m_has_field_do_on_un_eabled self._m_has_field_do_on_un_eabled = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_do_on_un_eabled', None) @property def has_field_limit_horizontal(self): if hasattr(self, '_m_has_field_limit_horizontal'): return self._m_has_field_limit_horizontal self._m_has_field_limit_horizontal = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_limit_horizontal', None) @property def has_field_forward_by(self): if hasattr(self, '_m_has_field_forward_by'): return self._m_has_field_forward_by self._m_has_field_forward_by = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_forward_by', None) @property def has_field_limit_vertical(self): if hasattr(self, '_m_has_field_limit_vertical'): return self._m_has_field_limit_vertical self._m_has_field_limit_vertical = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_limit_vertical', None) @property def has_field_part_root_name(self): if hasattr(self, '_m_has_field_part_root_name'): return self._m_has_field_part_root_name self._m_has_field_part_root_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_part_root_name', None) @property def has_field_rotate_by(self): if hasattr(self, '_m_has_field_rotate_by'): return self._m_has_field_rotate_by self._m_has_field_rotate_by = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_rotate_by', None) @property def has_field_angular_speed(self): if hasattr(self, '_m_has_field_angular_speed'): return self._m_has_field_angular_speed self._m_has_field_angular_speed = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_angular_speed', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_forward_by_trans_name(self): if hasattr(self, '_m_has_field_forward_by_trans_name'): return self._m_has_field_forward_by_trans_name self._m_has_field_forward_by_trans_name = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_forward_by_trans_name', None) @property def has_field_forward_axial_fix(self): if hasattr(self, '_m_has_field_forward_axial_fix'): return self._m_has_field_forward_axial_fix self._m_has_field_forward_axial_fix = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_forward_axial_fix', None) class ConfigAudioPositionedOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioOperation(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_positioning: self.positioning = self._io.read_f4le() @property def has_field_positioning(self): if hasattr(self, '_m_has_field_positioning'): return self._m_has_field_positioning self._m_has_field_positioning = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_positioning', None) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class ArrayOfConfigDialogSchemeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigDialogScheme(self._io, self, self._root)) class EnumRefreshIndexType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RefreshIndexType, self.data.value) return getattr(self, '_m_value', None) class EnumMarkCustomType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkCustomType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumInputEventTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumInputEventType(self._io, self, self._root)) class IrodoriPoetryLineExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_var: self.var = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_content', None) @property def has_field_var(self): if hasattr(self, '_m_has_field_var'): return self._m_has_field_var self._m_has_field_var = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_var', None) class EnumQuestShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestShowType, self.data.value) return getattr(self, '_m_value', None) class GatherSaveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldEventExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_event_id: self.event_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_event_type: self.event_type = Output.EnumHomeAvatarEventType(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_id: self.talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_suit_id: self.furniture_suit_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lasttime: self.lasttime = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_type1: self.condition_type1 = Output.EnumHomeAvatarEventCondType(self._io, self, self._root) if self.has_field_condition_param1: self.condition_param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_type2: self.condition_type2 = Output.EnumHomeAvatarEventCondType(self._io, self, self._root) if self.has_field_condition_param2: self.condition_param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_condition_type2(self): if hasattr(self, '_m_has_field_condition_type2'): return self._m_has_field_condition_type2 self._m_has_field_condition_type2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_condition_type2', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_furniture_suit_id(self): if hasattr(self, '_m_has_field_furniture_suit_id'): return self._m_has_field_furniture_suit_id self._m_has_field_furniture_suit_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_furniture_suit_id', None) @property def has_field_condition_param2(self): if hasattr(self, '_m_has_field_condition_param2'): return self._m_has_field_condition_param2 self._m_has_field_condition_param2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_condition_param2', None) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_talk_id', None) @property def has_field_condition_param1(self): if hasattr(self, '_m_has_field_condition_param1'): return self._m_has_field_condition_param1 self._m_has_field_condition_param1 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_condition_param1', None) @property def has_field_event_type(self): if hasattr(self, '_m_has_field_event_type'): return self._m_has_field_event_type self._m_has_field_event_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_event_type', None) @property def has_field_lasttime(self): if hasattr(self, '_m_has_field_lasttime'): return self._m_has_field_lasttime self._m_has_field_lasttime = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_lasttime', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_event_id(self): if hasattr(self, '_m_has_field_event_id'): return self._m_has_field_event_id self._m_has_field_event_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_event_id', None) @property def has_field_condition_type1(self): if hasattr(self, '_m_has_field_condition_type1'): return self._m_has_field_condition_type1 self._m_has_field_condition_type1 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_condition_type1', None) class EnableSceneTransformByName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_transform_names: self.transform_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_transform_names(self): if hasattr(self, '_m_has_field_transform_names'): return self._m_has_field_transform_names self._m_has_field_transform_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_transform_names', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigFrameTransition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) class TransPointRewardConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id_vec: self.group_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_unlock_area_id_vec: self.unlock_area_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_unlock_area_id_vec(self): if hasattr(self, '_m_has_field_unlock_area_id_vec'): return self._m_has_field_unlock_area_id_vec self._m_has_field_unlock_area_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_area_id_vec', None) @property def has_field_group_id_vec(self): if hasattr(self, '_m_has_field_group_id_vec'): return self._m_has_field_group_id_vec self._m_has_field_group_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id_vec', None) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_scene_id', None) class EnumTargetAltitudeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetAltitudeType, self.data.value) return getattr(self, '_m_value', None) class MonsterDefendAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_on_defend_succeded: self.on_defend_succeded = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_on_defend_succeded(self): if hasattr(self, '_m_has_field_on_defend_succeded'): return self._m_has_field_on_defend_succeded self._m_has_field_on_defend_succeded = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_defend_succeded', None) class ArrayOfTokenJsonPathLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TokenJsonPath(self._io, self, self._root)) class ArrayOfConfigAbilitySystemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAbilitySystem(self._io, self, self._root)) class VibrationSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_rtpc: self.rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_open_value: self.open_value = self._io.read_f4le() if self.has_field_close_value: self.close_value = self._io.read_f4le() @property def has_field_rtpc(self): if hasattr(self, '_m_has_field_rtpc'): return self._m_has_field_rtpc self._m_has_field_rtpc = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_rtpc', None) @property def has_field_open_value(self): if hasattr(self, '_m_has_field_open_value'): return self._m_has_field_open_value self._m_has_field_open_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_open_value', None) @property def has_field_close_value(self): if hasattr(self, '_m_has_field_close_value'): return self._m_has_field_close_value self._m_has_field_close_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_close_value', None) class ConfigWidgetOneoffGatherPointDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_radius: self.hint_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_nearby_radius: self.nearby_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grid_search_range: self.grid_search_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_gadget_id: self.success_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_failed_gadget_id: self.failed_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_point_type: self.gather_point_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_last_time: self.effect_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_success_gadget_id(self): if hasattr(self, '_m_has_field_success_gadget_id'): return self._m_has_field_success_gadget_id self._m_has_field_success_gadget_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_success_gadget_id', None) @property def has_field_nearby_radius(self): if hasattr(self, '_m_has_field_nearby_radius'): return self._m_has_field_nearby_radius self._m_has_field_nearby_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_nearby_radius', None) @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_hint_group', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_effect_last_time(self): if hasattr(self, '_m_has_field_effect_last_time'): return self._m_has_field_effect_last_time self._m_has_field_effect_last_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_effect_last_time', None) @property def has_field_gather_point_type(self): if hasattr(self, '_m_has_field_gather_point_type'): return self._m_has_field_gather_point_type self._m_has_field_gather_point_type = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gather_point_type', None) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_hint_radius(self): if hasattr(self, '_m_has_field_hint_radius'): return self._m_has_field_hint_radius self._m_has_field_hint_radius = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_hint_radius', None) @property def has_field_grid_search_range(self): if hasattr(self, '_m_has_field_grid_search_range'): return self._m_has_field_grid_search_range self._m_has_field_grid_search_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_grid_search_range', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def has_field_failed_gadget_id(self): if hasattr(self, '_m_has_field_failed_gadget_id'): return self._m_has_field_failed_gadget_id self._m_has_field_failed_gadget_id = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_failed_gadget_id', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class AdaptiveParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min: self.min = self._io.read_f4le() if self.has_field_max: self.max = self._io.read_f4le() if self.has_field_convincement: self.convincement = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max', None) @property def has_field_convincement(self): if hasattr(self, '_m_has_field_convincement'): return self._m_has_field_convincement self._m_has_field_convincement = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_convincement', None) class ConfigBaseStateLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_layer_index: self.layer_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_layer_index_name: self.layer_index_name = AuxTypes.String(self._io, self, self._root) @property def has_field_layer_index(self): if hasattr(self, '_m_has_field_layer_index'): return self._m_has_field_layer_index self._m_has_field_layer_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_layer_index', None) @property def has_field_layer_index_name(self): if hasattr(self, '_m_has_field_layer_index_name'): return self._m_has_field_layer_index_name self._m_has_field_layer_index_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_layer_index_name', None) class OraionokamiDescExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TowerScheduleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entrance_floor_id: self.entrance_floor_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_schedules: self.schedules = Output.ArrayOfTowerScheduleLengthS(self._io, self, self._root) if self.has_field_close_time: self.close_time = AuxTypes.String(self._io, self, self._root) if self.has_field_reward_group: self.reward_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_rewards: self.schedule_rewards = Output.ArrayOfTowerStarRewardLengthS(self._io, self, self._root) if self.has_field_commemorative_reward: self.commemorative_reward = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monthly_level_config_id: self.monthly_level_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buffname: self.buffname = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_schedule_rewards(self): if hasattr(self, '_m_has_field_schedule_rewards'): return self._m_has_field_schedule_rewards self._m_has_field_schedule_rewards = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_schedule_rewards', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_buffname(self): if hasattr(self, '_m_has_field_buffname'): return self._m_has_field_buffname self._m_has_field_buffname = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_buffname', None) @property def has_field_close_time(self): if hasattr(self, '_m_has_field_close_time'): return self._m_has_field_close_time self._m_has_field_close_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_close_time', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_reward_group(self): if hasattr(self, '_m_has_field_reward_group'): return self._m_has_field_reward_group self._m_has_field_reward_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_group', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_monthly_level_config_id(self): if hasattr(self, '_m_has_field_monthly_level_config_id'): return self._m_has_field_monthly_level_config_id self._m_has_field_monthly_level_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_monthly_level_config_id', None) @property def has_field_entrance_floor_id(self): if hasattr(self, '_m_has_field_entrance_floor_id'): return self._m_has_field_entrance_floor_id self._m_has_field_entrance_floor_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_entrance_floor_id', None) @property def has_field_schedules(self): if hasattr(self, '_m_has_field_schedules'): return self._m_has_field_schedules self._m_has_field_schedules = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_schedules', None) @property def has_field_commemorative_reward(self): if hasattr(self, '_m_has_field_commemorative_reward'): return self._m_has_field_commemorative_reward self._m_has_field_commemorative_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_commemorative_reward', None) class TemplateReminderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_style: self.style = Output.EnumTemplateReminderStyleType(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_type: self.activity_type = Output.EnumNewActivityType(self._io, self, self._root) if self.has_field_show_time: self.show_time = self._io.read_f4le() if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_activity_type(self): if hasattr(self, '_m_has_field_activity_type'): return self._m_has_field_activity_type self._m_has_field_activity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_activity_type', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_show_time(self): if hasattr(self, '_m_has_field_show_time'): return self._m_has_field_show_time self._m_has_field_show_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_time', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_style(self): if hasattr(self, '_m_has_field_style'): return self._m_has_field_style self._m_has_field_style = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_style', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_content', None) class SummerTimeV2overallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalCollision(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_high_spd_threshold: self.high_spd_threshold = self._io.read_f4le() @property def has_field_high_spd_threshold(self): if hasattr(self, '_m_has_field_high_spd_threshold'): return self._m_has_field_high_spd_threshold self._m_has_field_high_spd_threshold = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_high_spd_threshold', None) class IrodoriPoetryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByScenePropState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumSceneObjState(self._io, self, self._root) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_type', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigAudioBaseMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_move_rtpc_key: self.move_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_platform_settings: self.platform_settings = Output.ArrayOfAudioPlatformMoveSettingsLengthU(self._io, self, self._root) if self.has_field_platform_setting_usage_mapping: self.platform_setting_usage_mapping = Output.ArrayOfAudioPlatformMoveSettingsUsagePairLengthU(self._io, self, self._root) @property def has_field_move_rtpc_key(self): if hasattr(self, '_m_has_field_move_rtpc_key'): return self._m_has_field_move_rtpc_key self._m_has_field_move_rtpc_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_move_rtpc_key', None) @property def has_field_platform_settings(self): if hasattr(self, '_m_has_field_platform_settings'): return self._m_has_field_platform_settings self._m_has_field_platform_settings = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_platform_settings', None) @property def has_field_platform_setting_usage_mapping(self): if hasattr(self, '_m_has_field_platform_setting_usage_mapping'): return self._m_has_field_platform_setting_usage_mapping self._m_has_field_platform_setting_usage_mapping = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_platform_setting_usage_mapping', None) class MpPlayStatisticConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMistTrialStatisticType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MistTrialStatisticType, self.data.value) return getattr(self, '_m_value', None) class VehicleSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_name: self.skill_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_desc: self.skill_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_icon: self.skill_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_cd: self.skill_cd = self._io.read_f4le() if self.has_field_max_charge_count: self.max_charge_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trigger_id: self.trigger_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_lock_shape: self.lock_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_lock_weight_params: self.lock_weight_params = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_energy_once_cost: self.energy_once_cost = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_energy_max_cost: self.energy_max_cost = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_lock_shape(self): if hasattr(self, '_m_has_field_lock_shape'): return self._m_has_field_lock_shape self._m_has_field_lock_shape = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_lock_shape', None) @property def has_field_energy_max_cost(self): if hasattr(self, '_m_has_field_energy_max_cost'): return self._m_has_field_energy_max_cost self._m_has_field_energy_max_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_energy_max_cost', None) @property def has_field_skill_desc(self): if hasattr(self, '_m_has_field_skill_desc'): return self._m_has_field_skill_desc self._m_has_field_skill_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_skill_desc', None) @property def has_field_skill_name(self): if hasattr(self, '_m_has_field_skill_name'): return self._m_has_field_skill_name self._m_has_field_skill_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_name', None) @property def has_field_max_charge_count(self): if hasattr(self, '_m_has_field_max_charge_count'): return self._m_has_field_max_charge_count self._m_has_field_max_charge_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_max_charge_count', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_energy_once_cost(self): if hasattr(self, '_m_has_field_energy_once_cost'): return self._m_has_field_energy_once_cost self._m_has_field_energy_once_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_energy_once_cost', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_skill_cd(self): if hasattr(self, '_m_has_field_skill_cd'): return self._m_has_field_skill_cd self._m_has_field_skill_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_skill_cd', None) @property def has_field_lock_weight_params(self): if hasattr(self, '_m_has_field_lock_weight_params'): return self._m_has_field_lock_weight_params self._m_has_field_lock_weight_params = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_lock_weight_params', None) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_trigger_id', None) @property def has_field_skill_icon(self): if hasattr(self, '_m_has_field_skill_icon'): return self._m_has_field_skill_icon self._m_has_field_skill_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_skill_icon', None) class ChannellerSlabBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomMainQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CusmtomGadgetConfigIdExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumSceneSurfaceTypeDictOfEnumEFootprintPlatformConfigFootprintEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumSceneSurfaceType(self._io, self, self._root) self.value = Output.DictOfEnumEFootprintPlatformConfigFootprintEffect(self._io, self, self._root) class ArrayOfPackageContentConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.PackageContentConfig(self._io, self, self._root)) class DoActionByCreateGadgetMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumCreateGadgetMixinType(self._io, self, self._root) if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class BartenderFormulaExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_base_material: self.base_material = Output.ArrayOfBartenderMaterialLengthS(self._io, self, self._root) if self.has_field_extra_material: self.extra_material = Output.ArrayOfBartenderMaterialLengthS(self._io, self, self._root) if self.has_field_available_affix_list: self.available_affix_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mixing_state: self.mixing_state = Output.EnumBartenderMixingState(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lock_type: self.lock_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_blurred_desc: self.blurred_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_available_affix_list(self): if hasattr(self, '_m_has_field_available_affix_list'): return self._m_has_field_available_affix_list self._m_has_field_available_affix_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_available_affix_list', None) @property def has_field_extra_material(self): if hasattr(self, '_m_has_field_extra_material'): return self._m_has_field_extra_material self._m_has_field_extra_material = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_extra_material', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_lock_type(self): if hasattr(self, '_m_has_field_lock_type'): return self._m_has_field_lock_type self._m_has_field_lock_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_lock_type', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_base_material(self): if hasattr(self, '_m_has_field_base_material'): return self._m_has_field_base_material self._m_has_field_base_material = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_base_material', None) @property def has_field_blurred_desc(self): if hasattr(self, '_m_has_field_blurred_desc'): return self._m_has_field_blurred_desc self._m_has_field_blurred_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_blurred_desc', None) @property def has_field_mixing_state(self): if hasattr(self, '_m_has_field_mixing_state'): return self._m_has_field_mixing_state self._m_has_field_mixing_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mixing_state', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class DoActionByEventMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) if self.has_field_on_event: self.on_event = Output.EnumOnEventType(self._io, self, self._root) if self.has_field_pick_item_config_i_ds: self.pick_item_config_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_skill_ready_id: self.skill_ready_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_ability_state_added: self.on_ability_state_added = Output.ArrayOfConfigAbilityStateToActionsLengthU(self._io, self, self._root) if self.has_field_on_ability_state_removed: self.on_ability_state_removed = Output.ArrayOfConfigAbilityStateToActionsLengthU(self._io, self, self._root) if self.has_field_cost_energy_delta_name: self.cost_energy_delta_name = AuxTypes.String(self._io, self, self._root) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_pick_item_config_i_ds(self): if hasattr(self, '_m_has_field_pick_item_config_i_ds'): return self._m_has_field_pick_item_config_i_ds self._m_has_field_pick_item_config_i_ds = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_pick_item_config_i_ds', None) @property def has_field_on_event(self): if hasattr(self, '_m_has_field_on_event'): return self._m_has_field_on_event self._m_has_field_on_event = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_on_event', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_skill_ready_id(self): if hasattr(self, '_m_has_field_skill_ready_id'): return self._m_has_field_skill_ready_id self._m_has_field_skill_ready_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_skill_ready_id', None) @property def has_field_on_ability_state_added(self): if hasattr(self, '_m_has_field_on_ability_state_added'): return self._m_has_field_on_ability_state_added self._m_has_field_on_ability_state_added = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_ability_state_added', None) @property def has_field_on_ability_state_removed(self): if hasattr(self, '_m_has_field_on_ability_state_removed'): return self._m_has_field_on_ability_state_removed self._m_has_field_on_ability_state_removed = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_ability_state_removed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_cost_energy_delta_name(self): if hasattr(self, '_m_has_field_cost_energy_delta_name'): return self._m_has_field_cost_energy_delta_name self._m_has_field_cost_energy_delta_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_cost_energy_delta_name', None) class EnumStoryCameraTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StoryCameraTargetType, self.data.value) return getattr(self, '_m_value', None) class CameraLockMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trans_name: self.trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_cfg_path: self.cfg_path = AuxTypes.String(self._io, self, self._root) @property def has_field_trans_name(self): if hasattr(self, '_m_has_field_trans_name'): return self._m_has_field_trans_name self._m_has_field_trans_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trans_name', None) @property def has_field_cfg_path(self): if hasattr(self, '_m_has_field_cfg_path'): return self._m_has_field_cfg_path self._m_has_field_cfg_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cfg_path', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesVlqBase128LeSDeviceAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSDeviceAction(self._io, self, self._root)) class ArrayOfConfigAiRaycastConditionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiRaycastCondition(self._io, self, self._root)) class ConfigAiFollowScriptedPathSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFollowScriptedPathData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFollowScriptedPathData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class AsterTeamBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioMapArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_value: self.state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_sub_state_group: self.sub_state_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_default_sub_state_value: self.default_sub_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_events_on_enter: self.events_on_enter = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_events_on_exit: self.events_on_exit = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) @property def has_field_state_value(self): if hasattr(self, '_m_has_field_state_value'): return self._m_has_field_state_value self._m_has_field_state_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_value', None) @property def has_field_sub_state_group(self): if hasattr(self, '_m_has_field_sub_state_group'): return self._m_has_field_sub_state_group self._m_has_field_sub_state_group = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sub_state_group', None) @property def has_field_events_on_enter(self): if hasattr(self, '_m_has_field_events_on_enter'): return self._m_has_field_events_on_enter self._m_has_field_events_on_enter = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_events_on_enter', None) @property def has_field_default_sub_state_value(self): if hasattr(self, '_m_has_field_default_sub_state_value'): return self._m_has_field_default_sub_state_value self._m_has_field_default_sub_state_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_sub_state_value', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_events_on_exit(self): if hasattr(self, '_m_has_field_events_on_exit'): return self._m_has_field_events_on_exit self._m_has_field_events_on_exit = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_events_on_exit', None) class AttackCostTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PlayerLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiInvestigateSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiInvestigateData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiInvestigateData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ResetAnimatorTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_id: self.trigger_id = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_id', None) class EnumItemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemType, self.data.value) return getattr(self, '_m_value', None) class ConfigElemBall(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumElemBallTriggerType(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_cur_max_num: self.cur_max_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_interval_times: self.interval_times = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_drop_items: self.drop_items = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_drop_counts: self.drop_counts = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_poisson_disk: self.poisson_disk = self._io.read_f4le() if self.has_field_min_radius: self.min_radius = self._io.read_f4le() if self.has_field_max_radius: self.max_radius = self._io.read_f4le() @property def has_field_cur_max_num(self): if hasattr(self, '_m_has_field_cur_max_num'): return self._m_has_field_cur_max_num self._m_has_field_cur_max_num = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_cur_max_num', None) @property def has_field_min_radius(self): if hasattr(self, '_m_has_field_min_radius'): return self._m_has_field_min_radius self._m_has_field_min_radius = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_min_radius', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_max_num', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_interval_times(self): if hasattr(self, '_m_has_field_interval_times'): return self._m_has_field_interval_times self._m_has_field_interval_times = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_interval_times', None) @property def has_field_drop_items(self): if hasattr(self, '_m_has_field_drop_items'): return self._m_has_field_drop_items self._m_has_field_drop_items = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_drop_items', None) @property def has_field_drop_counts(self): if hasattr(self, '_m_has_field_drop_counts'): return self._m_has_field_drop_counts self._m_has_field_drop_counts = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_drop_counts', None) @property def has_field_max_radius(self): if hasattr(self, '_m_has_field_max_radius'): return self._m_has_field_max_radius self._m_has_field_max_radius = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_max_radius', None) @property def has_field_poisson_disk(self): if hasattr(self, '_m_has_field_poisson_disk'): return self._m_has_field_poisson_disk self._m_has_field_poisson_disk = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_poisson_disk', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_element_type', None) class EnumGuidePageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuidePageType, self.data.value) return getattr(self, '_m_value', None) class DoActionByEnergyChangeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) if self.has_field_element_types: self.element_types = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_do_when_energy_max: self.do_when_energy_max = self._io.read_u1() if self.has_field_on_gain_energy_by_ball: self.on_gain_energy_by_ball = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_gain_energy_by_other: self.on_gain_energy_by_other = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_gain_energy_by_all: self.on_gain_energy_by_all = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_gain_energy_max: self.on_gain_energy_max = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_gain_energy_by_ball(self): if hasattr(self, '_m_has_field_on_gain_energy_by_ball'): return self._m_has_field_on_gain_energy_by_ball self._m_has_field_on_gain_energy_by_ball = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_gain_energy_by_ball', None) @property def has_field_on_gain_energy_by_other(self): if hasattr(self, '_m_has_field_on_gain_energy_by_other'): return self._m_has_field_on_gain_energy_by_other self._m_has_field_on_gain_energy_by_other = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_gain_energy_by_other', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_on_gain_energy_max(self): if hasattr(self, '_m_has_field_on_gain_energy_max'): return self._m_has_field_on_gain_energy_max self._m_has_field_on_gain_energy_max = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_on_gain_energy_max', None) @property def has_field_on_gain_energy_by_all(self): if hasattr(self, '_m_has_field_on_gain_energy_by_all'): return self._m_has_field_on_gain_energy_by_all self._m_has_field_on_gain_energy_by_all = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_on_gain_energy_by_all', None) @property def has_field_do_when_energy_max(self): if hasattr(self, '_m_has_field_do_when_energy_max'): return self._m_has_field_do_when_energy_max self._m_has_field_do_when_energy_max = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_do_when_energy_max', None) @property def has_field_element_types(self): if hasattr(self, '_m_has_field_element_types'): return self._m_has_field_element_types self._m_has_field_element_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_types', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ByBigTeamHasElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class AnimalCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_shop_id: self.shop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) if self.has_field_refresh_type: self.refresh_type = Output.EnumShopRefreshType(self._io, self, self._root) if self.has_field_refresh_param: self.refresh_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_state_type: self.open_state_type = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_discount_level: self.city_discount_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scoin_discount_rate: self.scoin_discount_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vip_func_id: self.vip_func_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_refresh_param(self): if hasattr(self, '_m_has_field_refresh_param'): return self._m_has_field_refresh_param self._m_has_field_refresh_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_refresh_param', None) @property def has_field_scoin_discount_rate(self): if hasattr(self, '_m_has_field_scoin_discount_rate'): return self._m_has_field_scoin_discount_rate self._m_has_field_scoin_discount_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_scoin_discount_rate', None) @property def has_field_vip_func_id(self): if hasattr(self, '_m_has_field_vip_func_id'): return self._m_has_field_vip_func_id self._m_has_field_vip_func_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_vip_func_id', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_city_discount_level(self): if hasattr(self, '_m_has_field_city_discount_level'): return self._m_has_field_city_discount_level self._m_has_field_city_discount_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_city_discount_level', None) @property def has_field_shop_id(self): if hasattr(self, '_m_has_field_shop_id'): return self._m_has_field_shop_id self._m_has_field_shop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_shop_id', None) @property def has_field_refresh_type(self): if hasattr(self, '_m_has_field_refresh_type'): return self._m_has_field_refresh_type self._m_has_field_refresh_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_refresh_type', None) @property def has_field_open_state_type(self): if hasattr(self, '_m_has_field_open_state_type'): return self._m_has_field_open_state_type self._m_has_field_open_state_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_open_state_type', None) class QuestCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ExpeditionChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_time: self.unlock_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_challenge_index: self.reward_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_name: self.challenge_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_desc: self.challenge_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_super_element: self.super_element = AuxTypes.String(self._io, self, self._root) if self.has_field_center_pos_list: self.center_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_center_radius: self.center_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_center_radius(self): if hasattr(self, '_m_has_field_center_radius'): return self._m_has_field_center_radius self._m_has_field_center_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_center_radius', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_challenge_desc(self): if hasattr(self, '_m_has_field_challenge_desc'): return self._m_has_field_challenge_desc self._m_has_field_challenge_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_challenge_desc', None) @property def has_field_challenge_name(self): if hasattr(self, '_m_has_field_challenge_name'): return self._m_has_field_challenge_name self._m_has_field_challenge_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_challenge_name', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_super_element(self): if hasattr(self, '_m_has_field_super_element'): return self._m_has_field_super_element self._m_has_field_super_element = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_super_element', None) @property def has_field_center_pos_list(self): if hasattr(self, '_m_has_field_center_pos_list'): return self._m_has_field_center_pos_list self._m_has_field_center_pos_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_center_pos_list', None) @property def has_field_reward_challenge_index(self): if hasattr(self, '_m_has_field_reward_challenge_index'): return self._m_has_field_reward_challenge_index self._m_has_field_reward_challenge_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_challenge_index', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_unlock_time(self): if hasattr(self, '_m_has_field_unlock_time'): return self._m_has_field_unlock_time self._m_has_field_unlock_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_time', None) class SetPoseFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_float_id: self.float_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_float_id(self): if hasattr(self, '_m_has_field_float_id'): return self._m_has_field_float_id self._m_has_field_float_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_float_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfAudioWeatherVoTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioWeatherVoTrigger(self._io, self, self._root)) class ArrayOfTalkCondExLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TalkCondEx(self._io, self, self._root)) class AvatarSkillDepotExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_energy_skill: self.energy_skill = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talent_skill: self.talent_skill = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skills: self.skills = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_sub_skills: self.sub_skills = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_attack_mode_skill: self.attack_mode_skill = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_leader_talent: self.leader_talent = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_abilities: self.extra_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_talents: self.talents = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_talent_star_name: self.talent_star_name = AuxTypes.String(self._io, self, self._root) if self.has_field_core_proud_skill_group_id: self.core_proud_skill_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_core_proud_avatar_promote_level: self.core_proud_avatar_promote_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_inherent_proud_skill_opens: self.inherent_proud_skill_opens = Output.ArrayOfProudSkillOpenConfigLengthS(self._io, self, self._root) if self.has_field_skill_depot_ability_group: self.skill_depot_ability_group = AuxTypes.String(self._io, self, self._root) @property def has_field_talent_star_name(self): if hasattr(self, '_m_has_field_talent_star_name'): return self._m_has_field_talent_star_name self._m_has_field_talent_star_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_talent_star_name', None) @property def has_field_talent_skill(self): if hasattr(self, '_m_has_field_talent_skill'): return self._m_has_field_talent_skill self._m_has_field_talent_skill = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_talent_skill', None) @property def has_field_talents(self): if hasattr(self, '_m_has_field_talents'): return self._m_has_field_talents self._m_has_field_talents = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_talents', None) @property def has_field_core_proud_skill_group_id(self): if hasattr(self, '_m_has_field_core_proud_skill_group_id'): return self._m_has_field_core_proud_skill_group_id self._m_has_field_core_proud_skill_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_core_proud_skill_group_id', None) @property def has_field_leader_talent(self): if hasattr(self, '_m_has_field_leader_talent'): return self._m_has_field_leader_talent self._m_has_field_leader_talent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_leader_talent', None) @property def has_field_inherent_proud_skill_opens(self): if hasattr(self, '_m_has_field_inherent_proud_skill_opens'): return self._m_has_field_inherent_proud_skill_opens self._m_has_field_inherent_proud_skill_opens = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_inherent_proud_skill_opens', None) @property def has_field_skills(self): if hasattr(self, '_m_has_field_skills'): return self._m_has_field_skills self._m_has_field_skills = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_skills', None) @property def has_field_sub_skills(self): if hasattr(self, '_m_has_field_sub_skills'): return self._m_has_field_sub_skills self._m_has_field_sub_skills = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sub_skills', None) @property def has_field_extra_abilities(self): if hasattr(self, '_m_has_field_extra_abilities'): return self._m_has_field_extra_abilities self._m_has_field_extra_abilities = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_extra_abilities', None) @property def has_field_core_proud_avatar_promote_level(self): if hasattr(self, '_m_has_field_core_proud_avatar_promote_level'): return self._m_has_field_core_proud_avatar_promote_level self._m_has_field_core_proud_avatar_promote_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_core_proud_avatar_promote_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_energy_skill(self): if hasattr(self, '_m_has_field_energy_skill'): return self._m_has_field_energy_skill self._m_has_field_energy_skill = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_energy_skill', None) @property def has_field_skill_depot_ability_group(self): if hasattr(self, '_m_has_field_skill_depot_ability_group'): return self._m_has_field_skill_depot_ability_group self._m_has_field_skill_depot_ability_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_skill_depot_ability_group', None) @property def has_field_attack_mode_skill(self): if hasattr(self, '_m_has_field_attack_mode_skill'): return self._m_has_field_attack_mode_skill self._m_has_field_attack_mode_skill = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_attack_mode_skill', None) class ConfigDirectionByLookAtEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class GalleryProgressScoreTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioGeneral(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pause_game_object_event: self.pause_game_object_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_resume_game_object_event: self.resume_game_object_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_pause_bus_event: self.pause_bus_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_resume_bus_event: self.resume_bus_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_stop_all_event: self.stop_all_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_permanent_sound_banks: self.permanent_sound_banks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_platform_permanent_banks: self.platform_permanent_banks = Output.DictOfAuxTypesStringArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_permanent_sound_banks(self): if hasattr(self, '_m_has_field_permanent_sound_banks'): return self._m_has_field_permanent_sound_banks self._m_has_field_permanent_sound_banks = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_permanent_sound_banks', None) @property def has_field_resume_bus_event(self): if hasattr(self, '_m_has_field_resume_bus_event'): return self._m_has_field_resume_bus_event self._m_has_field_resume_bus_event = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_resume_bus_event', None) @property def has_field_pause_game_object_event(self): if hasattr(self, '_m_has_field_pause_game_object_event'): return self._m_has_field_pause_game_object_event self._m_has_field_pause_game_object_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pause_game_object_event', None) @property def has_field_pause_bus_event(self): if hasattr(self, '_m_has_field_pause_bus_event'): return self._m_has_field_pause_bus_event self._m_has_field_pause_bus_event = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_pause_bus_event', None) @property def has_field_platform_permanent_banks(self): if hasattr(self, '_m_has_field_platform_permanent_banks'): return self._m_has_field_platform_permanent_banks self._m_has_field_platform_permanent_banks = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_platform_permanent_banks', None) @property def has_field_stop_all_event(self): if hasattr(self, '_m_has_field_stop_all_event'): return self._m_has_field_stop_all_event self._m_has_field_stop_all_event = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_stop_all_event', None) @property def has_field_resume_game_object_event(self): if hasattr(self, '_m_has_field_resume_game_object_event'): return self._m_has_field_resume_game_object_event self._m_has_field_resume_game_object_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_resume_game_object_event', None) class ConfigAiPatrolFollowSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiPatrolFollowData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiPatrolFollowData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class FurnitureDeployTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfStringKeyItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfStringKeyItem(self._io, self, self._root)) class WeaponTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiMixinSetFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_float_id: self.float_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_float_id(self): if hasattr(self, '_m_has_field_float_id'): return self._m_has_field_float_id self._m_has_field_float_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_float_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ConfigClimateMisc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_damping_time: self.damping_time = self._io.read_f4le() if self.has_field_fade_speed: self.fade_speed = self._io.read_f4le() @property def has_field_damping_time(self): if hasattr(self, '_m_has_field_damping_time'): return self._m_has_field_damping_time self._m_has_field_damping_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_damping_time', None) @property def has_field_fade_speed(self): if hasattr(self, '_m_has_field_fade_speed'): return self._m_has_field_fade_speed self._m_has_field_fade_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fade_speed', None) class RoutineFinishContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_finish_type: self.finish_type = Output.EnumRoutineFinishType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_finish_type(self): if hasattr(self, '_m_has_field_finish_type'): return self._m_has_field_finish_type self._m_has_field_finish_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_finish_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_progress', None) class ContextPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopmallEntranceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicInfoConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTowerCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TowerCondType, self.data.value) return getattr(self, '_m_value', None) class ExploreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RejectAttackMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tag: self.attack_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_limit_time: self.limit_time = self._io.read_f4le() if self.has_field_type: self.type = Output.EnumRejectEventType(self._io, self, self._root) @property def has_field_attack_tag(self): if hasattr(self, '_m_has_field_attack_tag'): return self._m_has_field_attack_tag self._m_has_field_attack_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tag', None) @property def has_field_limit_time(self): if hasattr(self, '_m_has_field_limit_time'): return self._m_has_field_limit_time self._m_has_field_limit_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_limit_time', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HomeWorldComfortLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCustomNodeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_parent_index: self.parent_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_slot_identifier: self.slot_identifier = AuxTypes.String(self._io, self, self._root) @property def has_field_parent_index(self): if hasattr(self, '_m_has_field_parent_index'): return self._m_has_field_parent_index self._m_has_field_parent_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_parent_index', None) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_slot_identifier(self): if hasattr(self, '_m_has_field_slot_identifier'): return self._m_has_field_slot_identifier self._m_has_field_slot_identifier = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_slot_identifier', None) class MusicGameDrumConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BattlePassMissionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlayScoreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumMpPlayType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_calc_score: self.is_calc_score = self._io.read_u1() @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_is_calc_score(self): if hasattr(self, '_m_has_field_is_calc_score'): return self._m_has_field_is_calc_score self._m_has_field_is_calc_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_calc_score', None) class KvpOfDictEnumActionSlotTypeArrayOfConfigActionButtonLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumActionSlotType(self._io, self, self._root) self.value = Output.ArrayOfConfigActionButtonLengthU(self._io, self, self._root) class DispContextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ContextActionSetIcon(self._io, self, self._root) elif _on == 10: self.data = Output.ContextActionSetTextWithMainQuestName(self._io, self, self._root) elif _on == 0: self.data = Output.ContextAction(self._io, self, self._root) elif _on == 4: self.data = Output.ContextActionSelectSceneMark(self._io, self, self._root) elif _on == 6: self.data = Output.ContextActionCreateQuestAcceptionMark(self._io, self, self._root) elif _on == 7: self.data = Output.ContextActionSelectLegendQuest(self._io, self, self._root) elif _on == 1: self.data = Output.ContextActionExecuteAll(self._io, self, self._root) elif _on == 13: self.data = Output.ContextActionReportActivityBuriedPoint(self._io, self, self._root) elif _on == 11: self.data = Output.ContextActionSetActive(self._io, self, self._root) elif _on == 12: self.data = Output.ContextActionSetAnimatorTrigger(self._io, self, self._root) elif _on == 3: self.data = Output.ContextActionSelectMainQuest(self._io, self, self._root) elif _on == 5: self.data = Output.ContextActionSelectTransPoint(self._io, self, self._root) elif _on == 8: self.data = Output.ContextActionSelectChapterOngoingMainQuest(self._io, self, self._root) elif _on == 9: self.data = Output.ContextActionSetText(self._io, self, self._root) elif _on == 2: self.data = Output.ContextActionSelectMonsterMark(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DragonSpinePhaseComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalkSelectTimeOutExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_limit: self.time_limit = self._io.read_f4le() if self.has_field_next_talk_id: self.next_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_time_limit(self): if hasattr(self, '_m_has_field_time_limit'): return self._m_has_field_time_limit self._m_has_field_time_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_time_limit', None) @property def has_field_next_talk_id(self): if hasattr(self, '_m_has_field_next_talk_id'): return self._m_has_field_next_talk_id self._m_has_field_next_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_next_talk_id', None) class HomeWorldFurnitureExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_furniture_gadget_id: self.furniture_gadget_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_furn_type: self.furn_type = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_surface_type: self.surface_type = Output.EnumFurnitureDeploySurfaceType(self._io, self, self._root) if self.has_field_arrange_limit: self.arrange_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_special_furniture: self.is_special_furniture = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_furniture_type: self.special_furniture_type = Output.EnumSpeicalFurnitureType(self._io, self, self._root) if self.has_field_room_scene_id: self.room_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grid_style: self.grid_style = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_comfort: self.comfort = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stack_limit: self.stack_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost: self.cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_discount_cost: self.discount_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_combinable_light: self.is_combinable_light = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_can_float: self.can_float = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_unique: self.is_unique = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_icon: self.item_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_icon: self.effect_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_clamp_distance: self.clamp_distance = self._io.read_f4le() if self.has_field_editor_clamp_distance: self.editor_clamp_distance = self._io.read_f4le() if self.has_field_deploy_glitch_index: self.deploy_glitch_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_record_type: self.group_record_type = Output.EnumGroupRecordType(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_height', None) @property def has_field_cost(self): if hasattr(self, '_m_has_field_cost'): return self._m_has_field_cost self._m_has_field_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cost', None) @property def has_field_furniture_gadget_id(self): if hasattr(self, '_m_has_field_furniture_gadget_id'): return self._m_has_field_furniture_gadget_id self._m_has_field_furniture_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_furniture_gadget_id', None) @property def has_field_can_float(self): if hasattr(self, '_m_has_field_can_float'): return self._m_has_field_can_float self._m_has_field_can_float = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_can_float', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_dropable', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_furn_type(self): if hasattr(self, '_m_has_field_furn_type'): return self._m_has_field_furn_type self._m_has_field_furn_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_furn_type', None) @property def has_field_is_combinable_light(self): if hasattr(self, '_m_has_field_is_combinable_light'): return self._m_has_field_is_combinable_light self._m_has_field_is_combinable_light = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_combinable_light', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 4) != 0)) return getattr(self, '_m_has_field_use_level', None) @property def has_field_stack_limit(self): if hasattr(self, '_m_has_field_stack_limit'): return self._m_has_field_stack_limit self._m_has_field_stack_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_stack_limit', None) @property def has_field_editor_clamp_distance(self): if hasattr(self, '_m_has_field_editor_clamp_distance'): return self._m_has_field_editor_clamp_distance self._m_has_field_editor_clamp_distance = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_editor_clamp_distance', None) @property def has_field_comfort(self): if hasattr(self, '_m_has_field_comfort'): return self._m_has_field_comfort self._m_has_field_comfort = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_comfort', None) @property def has_field_effect_icon(self): if hasattr(self, '_m_has_field_effect_icon'): return self._m_has_field_effect_icon self._m_has_field_effect_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_effect_icon', None) @property def has_field_arrange_limit(self): if hasattr(self, '_m_has_field_arrange_limit'): return self._m_has_field_arrange_limit self._m_has_field_arrange_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_arrange_limit', None) @property def has_field_is_unique(self): if hasattr(self, '_m_has_field_is_unique'): return self._m_has_field_is_unique self._m_has_field_is_unique = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_unique', None) @property def has_field_group_record_type(self): if hasattr(self, '_m_has_field_group_record_type'): return self._m_has_field_group_record_type self._m_has_field_group_record_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_group_record_type', None) @property def has_field_grid_style(self): if hasattr(self, '_m_has_field_grid_style'): return self._m_has_field_grid_style self._m_has_field_grid_style = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_grid_style', None) @property def has_field_is_special_furniture(self): if hasattr(self, '_m_has_field_is_special_furniture'): return self._m_has_field_is_special_furniture self._m_has_field_is_special_furniture = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_special_furniture', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 8) != 0)) return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_item_icon(self): if hasattr(self, '_m_has_field_item_icon'): return self._m_has_field_item_icon self._m_has_field_item_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_item_icon', None) @property def has_field_surface_type(self): if hasattr(self, '_m_has_field_surface_type'): return self._m_has_field_surface_type self._m_has_field_surface_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_surface_type', None) @property def has_field_room_scene_id(self): if hasattr(self, '_m_has_field_room_scene_id'): return self._m_has_field_room_scene_id self._m_has_field_room_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_room_scene_id', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_deploy_glitch_index(self): if hasattr(self, '_m_has_field_deploy_glitch_index'): return self._m_has_field_deploy_glitch_index self._m_has_field_deploy_glitch_index = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_deploy_glitch_index', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_item_type', None) @property def has_field_clamp_distance(self): if hasattr(self, '_m_has_field_clamp_distance'): return self._m_has_field_clamp_distance self._m_has_field_clamp_distance = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_clamp_distance', None) @property def has_field_discount_cost(self): if hasattr(self, '_m_has_field_discount_cost'): return self._m_has_field_discount_cost self._m_has_field_discount_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_discount_cost', None) @property def has_field_special_furniture_type(self): if hasattr(self, '_m_has_field_special_furniture_type'): return self._m_has_field_special_furniture_type self._m_has_field_special_furniture_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_special_furniture_type', None) class LevelSuppressExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuidePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ui_indicator: self.ui_indicator = Output.ConfigTemplateData(self._io, self, self._root) if self.has_field_disable_quest_arrow: self.disable_quest_arrow = self._io.read_u1() @property def has_field_ui_indicator(self): if hasattr(self, '_m_has_field_ui_indicator'): return self._m_has_field_ui_indicator self._m_has_field_ui_indicator = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_indicator', None) @property def has_field_disable_quest_arrow(self): if hasattr(self, '_m_has_field_disable_quest_arrow'): return self._m_has_field_disable_quest_arrow self._m_has_field_disable_quest_arrow = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_disable_quest_arrow', None) class ConfigAiFollowScriptedPathData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_turn_speed_override_walk: self.turn_speed_override_walk = self._io.read_f4le() if self.has_field_turn_speed_override_run: self.turn_speed_override_run = self._io.read_f4le() if self.has_field_spacial: self.spacial = self._io.read_u1() if self.has_field_spacial_roll: self.spacial_roll = self._io.read_u1() @property def has_field_turn_speed_override_walk(self): if hasattr(self, '_m_has_field_turn_speed_override_walk'): return self._m_has_field_turn_speed_override_walk self._m_has_field_turn_speed_override_walk = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_turn_speed_override_walk', None) @property def has_field_turn_speed_override_run(self): if hasattr(self, '_m_has_field_turn_speed_override_run'): return self._m_has_field_turn_speed_override_run self._m_has_field_turn_speed_override_run = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override_run', None) @property def has_field_spacial(self): if hasattr(self, '_m_has_field_spacial'): return self._m_has_field_spacial self._m_has_field_spacial = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_spacial', None) @property def has_field_spacial_roll(self): if hasattr(self, '_m_has_field_spacial_roll'): return self._m_has_field_spacial_roll self._m_has_field_spacial_roll = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_spacial_roll', None) class ActivityGachaRobotExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_robot_id: self.robot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shape_list: self.shape_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_color_list: self.color_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_action_list: self.action_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumActivityGachaRobot(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_model_path: self.model_path = AuxTypes.String(self._io, self, self._root) if self.has_field_animator_id: self.animator_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_interval: self.play_interval = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_audio: self.audio = AuxTypes.String(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_robot_id(self): if hasattr(self, '_m_has_field_robot_id'): return self._m_has_field_robot_id self._m_has_field_robot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_robot_id', None) @property def has_field_animator_id(self): if hasattr(self, '_m_has_field_animator_id'): return self._m_has_field_animator_id self._m_has_field_animator_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_animator_id', None) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_action_list', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_audio', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_model_path(self): if hasattr(self, '_m_has_field_model_path'): return self._m_has_field_model_path self._m_has_field_model_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_model_path', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_color_list(self): if hasattr(self, '_m_has_field_color_list'): return self._m_has_field_color_list self._m_has_field_color_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_color_list', None) @property def has_field_shape_list(self): if hasattr(self, '_m_has_field_shape_list'): return self._m_has_field_shape_list self._m_has_field_shape_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_shape_list', None) @property def has_field_play_interval(self): if hasattr(self, '_m_has_field_play_interval'): return self._m_has_field_play_interval self._m_has_field_play_interval = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_play_interval', None) class EnumCoopNodeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopNodeType, self.data.value) return getattr(self, '_m_value', None) class ActivityUpAvatarExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id_list: self.avatar_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_avatar_id_list(self): if hasattr(self, '_m_has_field_avatar_id_list'): return self._m_has_field_avatar_id_list self._m_has_field_avatar_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_avatar_id_list', None) class GlobalMainShieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shield_type: self.shield_type = AuxTypes.String(self._io, self, self._root) if self.has_field_shield_angle: self.shield_angle = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp_ratio: self.shield_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp: self.shield_hp = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cost_shield_ratio_name: self.cost_shield_ratio_name = AuxTypes.String(self._io, self, self._root) if self.has_field_show_damage_text: self.show_damage_text = AuxTypes.String(self._io, self, self._root) if self.has_field_on_shield_broken: self.on_shield_broken = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_amount_by_get_damage: self.amount_by_get_damage = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_child_shield_modifier_name: self.child_shield_modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_target_mute_hit_effect: self.target_mute_hit_effect = self._io.read_u1() if self.has_field_infinite_shield: self.infinite_shield = self._io.read_u1() if self.has_field_heal_limited_by_caster_max_hp_ratio: self.heal_limited_by_caster_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_heal_limited_by_local_creature_max_hp_ratio: self.heal_limited_by_local_creature_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_child_shield_modifier_name(self): if hasattr(self, '_m_has_field_child_shield_modifier_name'): return self._m_has_field_child_shield_modifier_name self._m_has_field_child_shield_modifier_name = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_child_shield_modifier_name', None) @property def has_field_target_mute_hit_effect(self): if hasattr(self, '_m_has_field_target_mute_hit_effect'): return self._m_has_field_target_mute_hit_effect self._m_has_field_target_mute_hit_effect = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_target_mute_hit_effect', None) @property def has_field_shield_type(self): if hasattr(self, '_m_has_field_shield_type'): return self._m_has_field_shield_type self._m_has_field_shield_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_shield_type', None) @property def has_field_infinite_shield(self): if hasattr(self, '_m_has_field_infinite_shield'): return self._m_has_field_infinite_shield self._m_has_field_infinite_shield = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_infinite_shield', None) @property def has_field_cost_shield_ratio_name(self): if hasattr(self, '_m_has_field_cost_shield_ratio_name'): return self._m_has_field_cost_shield_ratio_name self._m_has_field_cost_shield_ratio_name = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_cost_shield_ratio_name', None) @property def has_field_on_shield_broken(self): if hasattr(self, '_m_has_field_on_shield_broken'): return self._m_has_field_on_shield_broken self._m_has_field_on_shield_broken = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_shield_broken', None) @property def has_field_heal_limited_by_local_creature_max_hp_ratio(self): if hasattr(self, '_m_has_field_heal_limited_by_local_creature_max_hp_ratio'): return self._m_has_field_heal_limited_by_local_creature_max_hp_ratio self._m_has_field_heal_limited_by_local_creature_max_hp_ratio = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_heal_limited_by_local_creature_max_hp_ratio', None) @property def has_field_heal_limited_by_caster_max_hp_ratio(self): if hasattr(self, '_m_has_field_heal_limited_by_caster_max_hp_ratio'): return self._m_has_field_heal_limited_by_caster_max_hp_ratio self._m_has_field_heal_limited_by_caster_max_hp_ratio = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_heal_limited_by_caster_max_hp_ratio', None) @property def has_field_shield_angle(self): if hasattr(self, '_m_has_field_shield_angle'): return self._m_has_field_shield_angle self._m_has_field_shield_angle = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_shield_angle', None) @property def has_field_show_damage_text(self): if hasattr(self, '_m_has_field_show_damage_text'): return self._m_has_field_show_damage_text self._m_has_field_show_damage_text = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_damage_text', None) @property def has_field_shield_hp_ratio(self): if hasattr(self, '_m_has_field_shield_hp_ratio'): return self._m_has_field_shield_hp_ratio self._m_has_field_shield_hp_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shield_hp_ratio', None) @property def has_field_shield_hp(self): if hasattr(self, '_m_has_field_shield_hp'): return self._m_has_field_shield_hp self._m_has_field_shield_hp = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shield_hp', None) @property def has_field_amount_by_get_damage(self): if hasattr(self, '_m_has_field_amount_by_get_damage'): return self._m_has_field_amount_by_get_damage self._m_has_field_amount_by_get_damage = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_amount_by_get_damage', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictAuxTypesStringDictOfAuxTypesStringF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DictOfAuxTypesStringF4(self._io, self, self._root) class ConfigMusicUInt32listPresenceCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listMemberCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class AvatarSteerByCameraMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_angular_speed: self.angular_speed = self._io.read_f4le() if self.has_field_can_revive_stamina: self.can_revive_stamina = self._io.read_u1() if self.has_field_is_check_on_attach: self.is_check_on_attach = self._io.read_u1() @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_can_revive_stamina(self): if hasattr(self, '_m_has_field_can_revive_stamina'): return self._m_has_field_can_revive_stamina self._m_has_field_can_revive_stamina = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_can_revive_stamina', None) @property def has_field_angular_speed(self): if hasattr(self, '_m_has_field_angular_speed'): return self._m_has_field_angular_speed self._m_has_field_angular_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_angular_speed', None) @property def has_field_is_check_on_attach(self): if hasattr(self, '_m_has_field_is_check_on_attach'): return self._m_has_field_is_check_on_attach self._m_has_field_is_check_on_attach = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_check_on_attach', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class CoopActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAvatarHitBuckets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_avatar_hit_bucket_setting: self.override_avatar_hit_bucket_setting = Output.ConfigAvatarHitBucketSetting(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_override_avatar_hit_bucket_setting(self): if hasattr(self, '_m_has_field_override_avatar_hit_bucket_setting'): return self._m_has_field_override_avatar_hit_bucket_setting self._m_has_field_override_avatar_hit_bucket_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_avatar_hit_bucket_setting', None) class TryFindBlinkPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_forward_angle: self.forward_angle = self._io.read_f4le() if self.has_field_min_range: self.min_range = self._io.read_f4le() if self.has_field_max_range: self.max_range = self._io.read_f4le() if self.has_field_limit_y: self.limit_y = self._io.read_f4le() if self.has_field_ignore_water: self.ignore_water = self._io.read_u1() if self.has_field_check_in_camera: self.check_in_camera = self._io.read_u1() @property def has_field_forward_angle(self): if hasattr(self, '_m_has_field_forward_angle'): return self._m_has_field_forward_angle self._m_has_field_forward_angle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_forward_angle', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_max_range(self): if hasattr(self, '_m_has_field_max_range'): return self._m_has_field_max_range self._m_has_field_max_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_range', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_check_in_camera(self): if hasattr(self, '_m_has_field_check_in_camera'): return self._m_has_field_check_in_camera self._m_has_field_check_in_camera = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_check_in_camera', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_min_range(self): if hasattr(self, '_m_has_field_min_range'): return self._m_has_field_min_range self._m_has_field_min_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_range', None) @property def has_field_limit_y(self): if hasattr(self, '_m_has_field_limit_y'): return self._m_has_field_limit_y self._m_has_field_limit_y = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_limit_y', None) @property def has_field_ignore_water(self): if hasattr(self, '_m_has_field_ignore_water'): return self._m_has_field_ignore_water self._m_has_field_ignore_water = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ignore_water', None) class EnumShopmallEntranceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopmallEntranceType, self.data.value) return getattr(self, '_m_value', None) class GadgetCurveExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_curve_infos: self.curve_infos = Output.ArrayOfGrowCurveInfoLengthS(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_curve_infos(self): if hasattr(self, '_m_has_field_curve_infos'): return self._m_has_field_curve_infos self._m_has_field_curve_infos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_curve_infos', None) class WinterCampRaceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_watcher: self.score_watcher = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_score_list: self.score_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_time_factor: self.time_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gold_factor: self.gold_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limited_gold_factor: self.limited_gold_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_tips: self.item_tips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_score_watcher(self): if hasattr(self, '_m_has_field_score_watcher'): return self._m_has_field_score_watcher self._m_has_field_score_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_score_watcher', None) @property def has_field_item_tips(self): if hasattr(self, '_m_has_field_item_tips'): return self._m_has_field_item_tips self._m_has_field_item_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_item_tips', None) @property def has_field_limited_gold_factor(self): if hasattr(self, '_m_has_field_limited_gold_factor'): return self._m_has_field_limited_gold_factor self._m_has_field_limited_gold_factor = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_limited_gold_factor', None) @property def has_field_score_list(self): if hasattr(self, '_m_has_field_score_list'): return self._m_has_field_score_list self._m_has_field_score_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_score_list', None) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_gold_factor(self): if hasattr(self, '_m_has_field_gold_factor'): return self._m_has_field_gold_factor self._m_has_field_gold_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_gold_factor', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_time_factor(self): if hasattr(self, '_m_has_field_time_factor'): return self._m_has_field_time_factor self._m_has_field_time_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_time_factor', None) class DispConfigMusicStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 10: self.data = Output.ConfigMusicUIntAbsenceStimulusHandler(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigMusicStimulusHandler(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigMusicFloatStimulusHandler(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigMusicMultiValueParameterizedStimulusHandler(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigMusicUIntMultiValueStimulusHandler(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigMusicStringPresenceStimulusHandler(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigMusicStringAbsenceStimulusHandler(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigMusicUIntStimulusHandler(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigMusicStringStimulusHandler(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigMusicStringMultiValueStimulusHandler(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigMusicUIntPresenceStimulusHandler(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigMusicIntStimulusHandler(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigSpeedupField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigConstForceField(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attenuation: self.attenuation = self._io.read_f4le() if self.has_field_single_dir: self.single_dir = self._io.read_u1() if self.has_field_trigger_vehicle: self.trigger_vehicle = self._io.read_u1() if self.has_field_stop_velocity: self.stop_velocity = self._io.read_f4le() if self.has_field_vehicle_target_fov: self.vehicle_target_fov = self._io.read_f4le() if self.has_field_vehicle_target_fov_duration: self.vehicle_target_fov_duration = self._io.read_f4le() if self.has_field_vehicle_target_fov_priority: self.vehicle_target_fov_priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vehicle_fov_enter_speed: self.vehicle_fov_enter_speed = self._io.read_f4le() if self.has_field_vehicle_fov_exit_speed: self.vehicle_fov_exit_speed = self._io.read_f4le() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_trigger_vehicle(self): if hasattr(self, '_m_has_field_trigger_vehicle'): return self._m_has_field_trigger_vehicle self._m_has_field_trigger_vehicle = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_trigger_vehicle', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_vehicle_fov_enter_speed(self): if hasattr(self, '_m_has_field_vehicle_fov_enter_speed'): return self._m_has_field_vehicle_fov_enter_speed self._m_has_field_vehicle_fov_enter_speed = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_vehicle_fov_enter_speed', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def has_field_vehicle_fov_exit_speed(self): if hasattr(self, '_m_has_field_vehicle_fov_exit_speed'): return self._m_has_field_vehicle_fov_exit_speed self._m_has_field_vehicle_fov_exit_speed = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_vehicle_fov_exit_speed', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def has_field_vehicle_target_fov_duration(self): if hasattr(self, '_m_has_field_vehicle_target_fov_duration'): return self._m_has_field_vehicle_target_fov_duration self._m_has_field_vehicle_target_fov_duration = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_vehicle_target_fov_duration', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_stop_velocity(self): if hasattr(self, '_m_has_field_stop_velocity'): return self._m_has_field_stop_velocity self._m_has_field_stop_velocity = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_stop_velocity', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def has_field_single_dir(self): if hasattr(self, '_m_has_field_single_dir'): return self._m_has_field_single_dir self._m_has_field_single_dir = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_single_dir', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_vehicle_target_fov(self): if hasattr(self, '_m_has_field_vehicle_target_fov'): return self._m_has_field_vehicle_target_fov self._m_has_field_vehicle_target_fov = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_vehicle_target_fov', None) @property def has_field_vehicle_target_fov_priority(self): if hasattr(self, '_m_has_field_vehicle_target_fov_priority'): return self._m_has_field_vehicle_target_fov_priority self._m_has_field_vehicle_target_fov_priority = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_vehicle_target_fov_priority', None) class EnumCombatPropertyIndex(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CombatPropertyIndex, self.data.value) return getattr(self, '_m_value', None) class EnumOnEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OnEventType, self.data.value) return getattr(self, '_m_value', None) class EnumEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityType, self.data.value) return getattr(self, '_m_value', None) class DictOfEnumCoopTemperamentTypeCoopTemperament(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumCoopTemperamentTypeCoopTemperament(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeSConfigAiSpacialProbeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialProbeData(self._io, self, self._root)) class ConfigWidgetToyWaterSprite(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_trigger_name: self.ability_trigger_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_trigger_name_second: self.ability_trigger_name_second = AuxTypes.String(self._io, self, self._root) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_ability_trigger_name(self): if hasattr(self, '_m_has_field_ability_trigger_name'): return self._m_has_field_ability_trigger_name self._m_has_field_ability_trigger_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_trigger_name', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_ability_trigger_name_second(self): if hasattr(self, '_m_has_field_ability_trigger_name_second'): return self._m_has_field_ability_trigger_name_second self._m_has_field_ability_trigger_name_second = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_trigger_name_second', None) class DoActionByAnimatorStateIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_enter_predicates: self.enter_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_exit_predicates: self.exit_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_enter_actions: self.enter_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_exit_actions: self.exit_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_enter_actions(self): if hasattr(self, '_m_has_field_enter_actions'): return self._m_has_field_enter_actions self._m_has_field_enter_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enter_actions', None) @property def has_field_exit_predicates(self): if hasattr(self, '_m_has_field_exit_predicates'): return self._m_has_field_exit_predicates self._m_has_field_exit_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_exit_predicates', None) @property def has_field_exit_actions(self): if hasattr(self, '_m_has_field_exit_actions'): return self._m_has_field_exit_actions self._m_has_field_exit_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_exit_actions', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_enter_predicates(self): if hasattr(self, '_m_has_field_enter_predicates'): return self._m_has_field_enter_predicates self._m_has_field_enter_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enter_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictEnumActionPanelStateAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumActionPanelState(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class UnlockTalentParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_talent_param: self.talent_param = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_talent_param(self): if hasattr(self, '_m_has_field_talent_param'): return self._m_has_field_talent_param self._m_has_field_talent_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_talent_param', None) class HomeworldLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_comfort_point_limit: self.comfort_point_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_home_coin_store_limit: self.home_coin_store_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_home_fetter_exp_store_limit: self.home_fetter_exp_store_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_make_slot_count: self.furniture_make_slot_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_outdoor_unlock_block_count: self.outdoor_unlock_block_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_unlock_module_count: self.free_unlock_module_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_deploy_npc_count: self.deploy_npc_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_djinn_gadget_id: self.djinn_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_shop_goods_count: self.limit_shop_goods_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_limit_shop_goods_extra_count: self.limit_shop_goods_extra_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_funcs: self.level_funcs = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_home_fetter_exp_store_limit(self): if hasattr(self, '_m_has_field_home_fetter_exp_store_limit'): return self._m_has_field_home_fetter_exp_store_limit self._m_has_field_home_fetter_exp_store_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_home_fetter_exp_store_limit', None) @property def has_field_deploy_npc_count(self): if hasattr(self, '_m_has_field_deploy_npc_count'): return self._m_has_field_deploy_npc_count self._m_has_field_deploy_npc_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_deploy_npc_count', None) @property def has_field_limit_shop_goods_extra_count(self): if hasattr(self, '_m_has_field_limit_shop_goods_extra_count'): return self._m_has_field_limit_shop_goods_extra_count self._m_has_field_limit_shop_goods_extra_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_limit_shop_goods_extra_count', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_home_coin_store_limit(self): if hasattr(self, '_m_has_field_home_coin_store_limit'): return self._m_has_field_home_coin_store_limit self._m_has_field_home_coin_store_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_home_coin_store_limit', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_free_unlock_module_count(self): if hasattr(self, '_m_has_field_free_unlock_module_count'): return self._m_has_field_free_unlock_module_count self._m_has_field_free_unlock_module_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_free_unlock_module_count', None) @property def has_field_comfort_point_limit(self): if hasattr(self, '_m_has_field_comfort_point_limit'): return self._m_has_field_comfort_point_limit self._m_has_field_comfort_point_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_comfort_point_limit', None) @property def has_field_limit_shop_goods_count(self): if hasattr(self, '_m_has_field_limit_shop_goods_count'): return self._m_has_field_limit_shop_goods_count self._m_has_field_limit_shop_goods_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_limit_shop_goods_count', None) @property def has_field_outdoor_unlock_block_count(self): if hasattr(self, '_m_has_field_outdoor_unlock_block_count'): return self._m_has_field_outdoor_unlock_block_count self._m_has_field_outdoor_unlock_block_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_outdoor_unlock_block_count', None) @property def has_field_level_funcs(self): if hasattr(self, '_m_has_field_level_funcs'): return self._m_has_field_level_funcs self._m_has_field_level_funcs = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_level_funcs', None) @property def has_field_furniture_make_slot_count(self): if hasattr(self, '_m_has_field_furniture_make_slot_count'): return self._m_has_field_furniture_make_slot_count self._m_has_field_furniture_make_slot_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_furniture_make_slot_count', None) @property def has_field_djinn_gadget_id(self): if hasattr(self, '_m_has_field_djinn_gadget_id'): return self._m_has_field_djinn_gadget_id self._m_has_field_djinn_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_djinn_gadget_id', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_exp', None) class ByIsInReconnect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DoActionByDamageReceivedMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_param_type: self.param_type = Output.EnumDoActionByDamageReceivedParamType(self._io, self, self._root) if self.has_field_value_min: self.value_min = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_value_max: self.value_max = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_param_type(self): if hasattr(self, '_m_has_field_param_type'): return self._m_has_field_param_type self._m_has_field_param_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param_type', None) @property def has_field_value_min(self): if hasattr(self, '_m_has_field_value_min'): return self._m_has_field_value_min self._m_has_field_value_min = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value_min', None) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def has_field_value_max(self): if hasattr(self, '_m_has_field_value_max'): return self._m_has_field_value_max self._m_has_field_value_max = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value_max', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAiPatrolFollowData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_inner_distance: self.inner_distance = self._io.read_f4le() if self.has_field_speed_level_inner: self.speed_level_inner = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_out_distance: self.out_distance = self._io.read_f4le() if self.has_field_stop_distance: self.stop_distance = self._io.read_f4le() @property def has_field_speed_level_inner(self): if hasattr(self, '_m_has_field_speed_level_inner'): return self._m_has_field_speed_level_inner self._m_has_field_speed_level_inner = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_speed_level_inner', None) @property def has_field_out_distance(self): if hasattr(self, '_m_has_field_out_distance'): return self._m_has_field_out_distance self._m_has_field_out_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_out_distance', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_stop_distance(self): if hasattr(self, '_m_has_field_stop_distance'): return self._m_has_field_stop_distance self._m_has_field_stop_distance = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_stop_distance', None) @property def has_field_inner_distance(self): if hasattr(self, '_m_has_field_inner_distance'): return self._m_has_field_inner_distance self._m_has_field_inner_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_inner_distance', None) class MonsterTitleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_title_id: self.title_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_name: self.title_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_inverted: self.is_inverted = self._io.read_u1() @property def has_field_title_id(self): if hasattr(self, '_m_has_field_title_id'): return self._m_has_field_title_id self._m_has_field_title_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_title_id', None) @property def has_field_title_name(self): if hasattr(self, '_m_has_field_title_name'): return self._m_has_field_title_name self._m_has_field_title_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title_name', None) @property def has_field_is_inverted(self): if hasattr(self, '_m_has_field_is_inverted'): return self._m_has_field_is_inverted self._m_has_field_is_inverted = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_inverted', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiFollowScriptedPathData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFollowScriptedPathData(self._io, self, self._root) class FireworksReformParamConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumFireworksReformParamType(self._io, self, self._root) if self.has_field_standard_value: self.standard_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_can_reform: self.is_can_reform = self._io.read_u1() if self.has_field_value_range: self.value_range = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_standard_value(self): if hasattr(self, '_m_has_field_standard_value'): return self._m_has_field_standard_value self._m_has_field_standard_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_standard_value', None) @property def has_field_is_can_reform(self): if hasattr(self, '_m_has_field_is_can_reform'): return self._m_has_field_is_can_reform self._m_has_field_is_can_reform = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_can_reform', None) @property def has_field_value_range(self): if hasattr(self, '_m_has_field_value_range'): return self._m_has_field_value_range self._m_has_field_value_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_value_range', None) class RandomQuestTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MiracleTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShortIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySpiceFoodExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_normal_food_id: self.normal_food_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_food_id: self.special_food_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recipe_mat_id: self.recipe_mat_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_source_desc: self.source_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_normal_food_id(self): if hasattr(self, '_m_has_field_normal_food_id'): return self._m_has_field_normal_food_id self._m_has_field_normal_food_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_normal_food_id', None) @property def has_field_special_food_id(self): if hasattr(self, '_m_has_field_special_food_id'): return self._m_has_field_special_food_id self._m_has_field_special_food_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_special_food_id', None) @property def has_field_recipe_mat_id(self): if hasattr(self, '_m_has_field_recipe_mat_id'): return self._m_has_field_recipe_mat_id self._m_has_field_recipe_mat_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_recipe_mat_id', None) @property def has_field_source_desc(self): if hasattr(self, '_m_has_field_source_desc'): return self._m_has_field_source_desc self._m_has_field_source_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_source_desc', None) class ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root)) class EffectTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNpcStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigNormalStateIdInfo(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_can_be_inter: self.can_be_inter = self._io.read_u1() @property def set_animator_float(self): if hasattr(self, '_m_set_animator_float'): return self._m_set_animator_float self._m_set_animator_float = self.base.set_animator_float return getattr(self, '_m_set_animator_float', None) @property def can_do_skill(self): if hasattr(self, '_m_can_do_skill'): return self._m_can_do_skill self._m_can_do_skill = self.base.can_do_skill return getattr(self, '_m_can_do_skill', None) @property def enable_ccd(self): if hasattr(self, '_m_enable_ccd'): return self._m_enable_ccd self._m_enable_ccd = self.base.enable_ccd return getattr(self, '_m_enable_ccd', None) @property def culling_model_always_animate(self): if hasattr(self, '_m_culling_model_always_animate'): return self._m_culling_model_always_animate self._m_culling_model_always_animate = self.base.culling_model_always_animate return getattr(self, '_m_culling_model_always_animate', None) @property def add_endure(self): if hasattr(self, '_m_add_endure'): return self._m_add_endure self._m_add_endure = self.base.add_endure return getattr(self, '_m_add_endure', None) @property def reset_animator_trigger_on_exit(self): if hasattr(self, '_m_reset_animator_trigger_on_exit'): return self._m_reset_animator_trigger_on_exit self._m_reset_animator_trigger_on_exit = self.base.reset_animator_trigger_on_exit return getattr(self, '_m_reset_animator_trigger_on_exit', None) @property def mass_ratio(self): if hasattr(self, '_m_mass_ratio'): return self._m_mass_ratio self._m_mass_ratio = self.base.mass_ratio return getattr(self, '_m_mass_ratio', None) @property def animator_states(self): if hasattr(self, '_m_animator_states'): return self._m_animator_states self._m_animator_states = self.base.animator_states return getattr(self, '_m_animator_states', None) @property def combat_move_on_water(self): if hasattr(self, '_m_combat_move_on_water'): return self._m_combat_move_on_water self._m_combat_move_on_water = self.base.combat_move_on_water return getattr(self, '_m_combat_move_on_water', None) @property def set_animator_boolean(self): if hasattr(self, '_m_set_animator_boolean'): return self._m_set_animator_boolean self._m_set_animator_boolean = self.base.set_animator_boolean return getattr(self, '_m_set_animator_boolean', None) @property def handle_animator_state_immediately(self): if hasattr(self, '_m_handle_animator_state_immediately'): return self._m_handle_animator_state_immediately self._m_handle_animator_state_immediately = self.base.handle_animator_state_immediately return getattr(self, '_m_handle_animator_state_immediately', None) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def can_do_skill_start(self): if hasattr(self, '_m_can_do_skill_start'): return self._m_can_do_skill_start self._m_can_do_skill_start = self.base.can_do_skill_start return getattr(self, '_m_can_do_skill_start', None) @property def has_field_can_be_inter(self): if hasattr(self, '_m_has_field_can_be_inter'): return self._m_has_field_can_be_inter self._m_has_field_can_be_inter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_can_be_inter', None) @property def can_sync_move(self): if hasattr(self, '_m_can_sync_move'): return self._m_can_sync_move self._m_can_sync_move = self.base.can_sync_move return getattr(self, '_m_can_sync_move', None) @property def reset_animator_trigger_on_enter(self): if hasattr(self, '_m_reset_animator_trigger_on_enter'): return self._m_reset_animator_trigger_on_enter self._m_reset_animator_trigger_on_enter = self.base.reset_animator_trigger_on_enter return getattr(self, '_m_reset_animator_trigger_on_enter', None) @property def can_do_skill_end(self): if hasattr(self, '_m_can_do_skill_end'): return self._m_can_do_skill_end self._m_can_do_skill_end = self.base.can_do_skill_end return getattr(self, '_m_can_do_skill_end', None) @property def move_type(self): if hasattr(self, '_m_move_type'): return self._m_move_type self._m_move_type = self.base.move_type return getattr(self, '_m_move_type', None) @property def need_face_to_anim_param(self): if hasattr(self, '_m_need_face_to_anim_param'): return self._m_need_face_to_anim_param self._m_need_face_to_anim_param = self.base.need_face_to_anim_param return getattr(self, '_m_need_face_to_anim_param', None) @property def enable_rag_doll(self): if hasattr(self, '_m_enable_rag_doll'): return self._m_enable_rag_doll self._m_enable_rag_doll = self.base.enable_rag_doll return getattr(self, '_m_enable_rag_doll', None) class DispConfigBaseWidgetToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigWidgetToyFeather(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigWidgetToyMiracleRing(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigWidgetToyCamera(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBaseWidgetToy(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigWidgetToyClintDetector(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigWidgetFireworksLauncher(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigWidgetToyClintCollector(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigWidgetUseAttachAbilityTrigger(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigWidgetToyTreasureMapDetector(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigWidgetToyAnchorPoint(self._io, self, self._root) elif _on == 27: self.data = Output.ConfigWidgetActivityGacha(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigWidgetToyTakePhoto(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigWidgetToyOpenPage(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigWidgetToyWaterSprite(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigWidgetToyLunchBox(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigWidgetToyOneoffGatherPointDetector(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigWidgetUseAttachAbilityGroup(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigWidgetDigScanner(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigWidgetToyCreateGadgetBase(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigWidgetToyBlessingCamera(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigWidgetToyGadgetBuilder(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigWidgetLightStone(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigWidgetAddBuff(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigWidgetToyAbilityGroupGenerator(self._io, self, self._root) elif _on == 26: self.data = Output.ConfigWidgetToyCrystal(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigWidgetToyBonfire(self._io, self, self._root) elif _on == 25: self.data = Output.ConfigWidgetCaptureAnimal(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigWidgetToyAdeptiAbode(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class IceFloorMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_width: self.width = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_move_distance: self.move_distance = self._io.read_f4le() if self.has_field_min_interval: self.min_interval = self._io.read_f4le() if self.has_field_do_action: self.do_action = Output.DispConfigAbilityAction(self._io, self, self._root) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_move_distance(self): if hasattr(self, '_m_has_field_move_distance'): return self._m_has_field_move_distance self._m_has_field_move_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_move_distance', None) @property def has_field_do_action(self): if hasattr(self, '_m_has_field_do_action'): return self._m_has_field_do_action self._m_has_field_do_action = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_do_action', None) @property def has_field_width(self): if hasattr(self, '_m_has_field_width'): return self._m_has_field_width self._m_has_field_width = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_width', None) @property def has_field_min_interval(self): if hasattr(self, '_m_has_field_min_interval'): return self._m_has_field_min_interval self._m_has_field_min_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_interval', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumScenePointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ScenePointType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideShowPanelAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) class DictOfAuxTypesVlqBase128LeSConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigWwiseString(self._io, self, self._root)) class ActivityPotionStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id_list: self.level_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_buff_id_list: self.buff_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desciption: self.desciption = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_level_id_list(self): if hasattr(self, '_m_has_field_level_id_list'): return self._m_has_field_level_id_list self._m_has_field_level_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_id_list', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_desciption(self): if hasattr(self, '_m_has_field_desciption'): return self._m_has_field_desciption self._m_has_field_desciption = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desciption', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_buff_id_list(self): if hasattr(self, '_m_has_field_buff_id_list'): return self._m_has_field_buff_id_list self._m_has_field_buff_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_buff_id_list', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) class KvpOfDictAuxTypesVlqBase128LeUAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class EnumTaskId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TaskId, self.data.value) return getattr(self, '_m_value', None) class EnumNpcBodyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NpcBodyType, self.data.value) return getattr(self, '_m_value', None) class QuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sub_id: self.sub_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_id: self.main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_sub_id_set: self.sub_id_set = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_mp_block: self.is_mp_block = self._io.read_u1() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_step_desc: self.step_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_tips: self.guide_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_ban_type: self.ban_type = Output.EnumBanGroupType(self._io, self, self._root) if self.has_field_accept_cond_comb: self.accept_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_accept_cond: self.accept_cond = Output.ArrayOfQuestCondLengthS(self._io, self, self._root) if self.has_field_finish_cond_comb: self.finish_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_finish_cond: self.finish_cond = Output.ArrayOfQuestContentLengthS(self._io, self, self._root) if self.has_field_fail_cond_comb: self.fail_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_fail_cond: self.fail_cond = Output.ArrayOfQuestContentLengthS(self._io, self, self._root) if self.has_field_guide: self.guide = Output.QuestGuide(self._io, self, self._root) if self.has_field_show_guide: self.show_guide = Output.EnumShowQuestGuideType(self._io, self, self._root) if self.has_field_finish_parent: self.finish_parent = self._io.read_u1() if self.has_field_fail_parent: self.fail_parent = self._io.read_u1() if self.has_field_fail_parent_show: self.fail_parent_show = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_is_rewind: self.is_rewind = self._io.read_u1() if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_fail_exec: self.fail_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_begin_exec: self.begin_exec = Output.ArrayOfQuestExecLengthS(self._io, self, self._root) if self.has_field_exclusive_npc_list: self.exclusive_npc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_shared_npc_list: self.shared_npc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exclusive_npc_priority: self.exclusive_npc_priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exclusive_place_list: self.exclusive_place_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_finish_cond(self): if hasattr(self, '_m_has_field_finish_cond'): return self._m_has_field_finish_cond self._m_has_field_finish_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_finish_cond', None) @property def has_field_ban_type(self): if hasattr(self, '_m_has_field_ban_type'): return self._m_has_field_ban_type self._m_has_field_ban_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_ban_type', None) @property def has_field_fail_cond(self): if hasattr(self, '_m_has_field_fail_cond'): return self._m_has_field_fail_cond self._m_has_field_fail_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_fail_cond', None) @property def has_field_is_rewind(self): if hasattr(self, '_m_has_field_is_rewind'): return self._m_has_field_is_rewind self._m_has_field_is_rewind = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_is_rewind', None) @property def has_field_is_mp_block(self): if hasattr(self, '_m_has_field_is_mp_block'): return self._m_has_field_is_mp_block self._m_has_field_is_mp_block = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_mp_block', None) @property def has_field_finish_cond_comb(self): if hasattr(self, '_m_has_field_finish_cond_comb'): return self._m_has_field_finish_cond_comb self._m_has_field_finish_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_finish_cond_comb', None) @property def has_field_exclusive_place_list(self): if hasattr(self, '_m_has_field_exclusive_place_list'): return self._m_has_field_exclusive_place_list self._m_has_field_exclusive_place_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_exclusive_place_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_step_desc(self): if hasattr(self, '_m_has_field_step_desc'): return self._m_has_field_step_desc self._m_has_field_step_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_step_desc', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_finish_exec', None) @property def has_field_accept_cond_comb(self): if hasattr(self, '_m_has_field_accept_cond_comb'): return self._m_has_field_accept_cond_comb self._m_has_field_accept_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_accept_cond_comb', None) @property def has_field_main_id(self): if hasattr(self, '_m_has_field_main_id'): return self._m_has_field_main_id self._m_has_field_main_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_main_id', None) @property def has_field_sub_id_set(self): if hasattr(self, '_m_has_field_sub_id_set'): return self._m_has_field_sub_id_set self._m_has_field_sub_id_set = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sub_id_set', None) @property def has_field_fail_parent(self): if hasattr(self, '_m_has_field_fail_parent'): return self._m_has_field_fail_parent self._m_has_field_fail_parent = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_fail_parent', None) @property def has_field_fail_cond_comb(self): if hasattr(self, '_m_has_field_fail_cond_comb'): return self._m_has_field_fail_cond_comb self._m_has_field_fail_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_fail_cond_comb', None) @property def has_field_guide(self): if hasattr(self, '_m_has_field_guide'): return self._m_has_field_guide self._m_has_field_guide = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_guide', None) @property def has_field_shared_npc_list(self): if hasattr(self, '_m_has_field_shared_npc_list'): return self._m_has_field_shared_npc_list self._m_has_field_shared_npc_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_shared_npc_list', None) @property def has_field_exclusive_npc_priority(self): if hasattr(self, '_m_has_field_exclusive_npc_priority'): return self._m_has_field_exclusive_npc_priority self._m_has_field_exclusive_npc_priority = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_exclusive_npc_priority', None) @property def has_field_show_guide(self): if hasattr(self, '_m_has_field_show_guide'): return self._m_has_field_show_guide self._m_has_field_show_guide = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_show_guide', None) @property def has_field_begin_exec(self): if hasattr(self, '_m_has_field_begin_exec'): return self._m_has_field_begin_exec self._m_has_field_begin_exec = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_begin_exec', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_show_type', None) @property def has_field_sub_id(self): if hasattr(self, '_m_has_field_sub_id'): return self._m_has_field_sub_id self._m_has_field_sub_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sub_id', None) @property def has_field_fail_exec(self): if hasattr(self, '_m_has_field_fail_exec'): return self._m_has_field_fail_exec self._m_has_field_fail_exec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_fail_exec', None) @property def has_field_accept_cond(self): if hasattr(self, '_m_has_field_accept_cond'): return self._m_has_field_accept_cond self._m_has_field_accept_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_accept_cond', None) @property def has_field_guide_tips(self): if hasattr(self, '_m_has_field_guide_tips'): return self._m_has_field_guide_tips self._m_has_field_guide_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_guide_tips', None) @property def has_field_fail_parent_show(self): if hasattr(self, '_m_has_field_fail_parent_show'): return self._m_has_field_fail_parent_show self._m_has_field_fail_parent_show = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_fail_parent_show', None) @property def has_field_exclusive_npc_list(self): if hasattr(self, '_m_has_field_exclusive_npc_list'): return self._m_has_field_exclusive_npc_list self._m_has_field_exclusive_npc_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_exclusive_npc_list', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_finish_parent(self): if hasattr(self, '_m_has_field_finish_parent'): return self._m_has_field_finish_parent self._m_has_field_finish_parent = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_finish_parent', None) class KvpOfDictAuxTypesStringConfigPerformanceSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerformanceSetting(self._io, self, self._root) class ActivityArenaChallengePreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementHittingOtherPredicatedMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pre_predicates: self.pre_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_element_batch_predicateds: self.element_batch_predicateds = Output.ArrayOfElementBatchPredicatedLengthU(self._io, self, self._root) @property def has_field_pre_predicates(self): if hasattr(self, '_m_has_field_pre_predicates'): return self._m_has_field_pre_predicates self._m_has_field_pre_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pre_predicates', None) @property def has_field_element_batch_predicateds(self): if hasattr(self, '_m_has_field_element_batch_predicateds'): return self._m_has_field_element_batch_predicateds self._m_has_field_element_batch_predicateds = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_batch_predicateds', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class FleurFairPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_stay_time: self.activity_stay_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id: self.unlock_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_player_level: self.unlock_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gameplay_pre_quest: self.gameplay_pre_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_unlock_quest_id(self): if hasattr(self, '_m_has_field_unlock_quest_id'): return self._m_has_field_unlock_quest_id self._m_has_field_unlock_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_quest_id', None) @property def has_field_unlock_player_level(self): if hasattr(self, '_m_has_field_unlock_player_level'): return self._m_has_field_unlock_player_level self._m_has_field_unlock_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_player_level', None) @property def has_field_activity_stay_time(self): if hasattr(self, '_m_has_field_activity_stay_time'): return self._m_has_field_activity_stay_time self._m_has_field_activity_stay_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_stay_time', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_gameplay_pre_quest(self): if hasattr(self, '_m_has_field_gameplay_pre_quest'): return self._m_has_field_gameplay_pre_quest self._m_has_field_gameplay_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_gameplay_pre_quest', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class GuideHasAvatarTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFaceAnimationGlobal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type_defines: self.type_defines = Output.DictOfAuxTypesStringFaceAnimationTypeConfig(self._io, self, self._root) if self.has_field_path_defines: self.path_defines = Output.DictOfAuxTypesVlqBase128LeUFaceAnimationTSettingPathConfig(self._io, self, self._root) @property def has_field_type_defines(self): if hasattr(self, '_m_has_field_type_defines'): return self._m_has_field_type_defines self._m_has_field_type_defines = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type_defines', None) @property def has_field_path_defines(self): if hasattr(self, '_m_has_field_path_defines'): return self._m_has_field_path_defines self._m_has_field_path_defines = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_path_defines', None) class ArrayOfConfigCoopActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCoopAction(self._io, self, self._root)) class WinterCampSnowmanDetailExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_snowman_name: self.snowman_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_snowman_desc: self.snowman_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_cond_id: self.unlock_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_text: self.unlock_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_snowman_name(self): if hasattr(self, '_m_has_field_snowman_name'): return self._m_has_field_snowman_name self._m_has_field_snowman_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_snowman_name', None) @property def has_field_snowman_desc(self): if hasattr(self, '_m_has_field_snowman_desc'): return self._m_has_field_snowman_desc self._m_has_field_snowman_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_snowman_desc', None) @property def has_field_unlock_cond_id(self): if hasattr(self, '_m_has_field_unlock_cond_id'): return self._m_has_field_unlock_cond_id self._m_has_field_unlock_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_cond_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_unlock_text(self): if hasattr(self, '_m_has_field_unlock_text'): return self._m_has_field_unlock_text self._m_has_field_unlock_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_text', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ReliquarySetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_set_id: self.set_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_set_icon: self.set_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_set_need_num: self.set_need_num = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_equip_affix_id: self.equip_affix_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_disable_filter: self.disable_filter = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_contains_list: self.contains_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bag_sort_value: self.bag_sort_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sus: self.sus = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_text_list: self.text_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_set_need_num(self): if hasattr(self, '_m_has_field_set_need_num'): return self._m_has_field_set_need_num self._m_has_field_set_need_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_set_need_num', None) @property def has_field_bag_sort_value(self): if hasattr(self, '_m_has_field_bag_sort_value'): return self._m_has_field_bag_sort_value self._m_has_field_bag_sort_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_bag_sort_value', None) @property def has_field_sus(self): if hasattr(self, '_m_has_field_sus'): return self._m_has_field_sus self._m_has_field_sus = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_sus', None) @property def has_field_disable_filter(self): if hasattr(self, '_m_has_field_disable_filter'): return self._m_has_field_disable_filter self._m_has_field_disable_filter = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_disable_filter', None) @property def has_field_set_id(self): if hasattr(self, '_m_has_field_set_id'): return self._m_has_field_set_id self._m_has_field_set_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_set_id', None) @property def has_field_set_icon(self): if hasattr(self, '_m_has_field_set_icon'): return self._m_has_field_set_icon self._m_has_field_set_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_set_icon', None) @property def has_field_equip_affix_id(self): if hasattr(self, '_m_has_field_equip_affix_id'): return self._m_has_field_equip_affix_id self._m_has_field_equip_affix_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_equip_affix_id', None) @property def has_field_text_list(self): if hasattr(self, '_m_has_field_text_list'): return self._m_has_field_text_list self._m_has_field_text_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_text_list', None) @property def has_field_contains_list(self): if hasattr(self, '_m_has_field_contains_list'): return self._m_has_field_contains_list self._m_has_field_contains_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_contains_list', None) class VodPlayerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActionCompoundType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionCompoundType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfFightPropGrowConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FightPropGrowConfig(self._io, self, self._root)) class ConfigAudioAdaptiveDynamicRayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ray_cast_per_frame: self.ray_cast_per_frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_max_ray_len: self.max_ray_len = self._io.read_f4le() if self.has_field_debug: self.debug = self._io.read_u1() if self.has_field_default_sampling_level: self.default_sampling_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_openness_func_type: self.openness_func_type = Output.EnumOpennessFuncType(self._io, self, self._root) if self.has_field_label_map: self.label_map = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) if self.has_field_adaptive_param_map: self.adaptive_param_map = Output.DictOfAuxTypesVlqBase128LeUAdaptiveParam(self._io, self, self._root) if self.has_field_sampling_data: self.sampling_data = Output.SamplingData(self._io, self, self._root) @property def has_field_adaptive_param_map(self): if hasattr(self, '_m_has_field_adaptive_param_map'): return self._m_has_field_adaptive_param_map self._m_has_field_adaptive_param_map = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_adaptive_param_map', None) @property def has_field_sampling_data(self): if hasattr(self, '_m_has_field_sampling_data'): return self._m_has_field_sampling_data self._m_has_field_sampling_data = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_sampling_data', None) @property def has_field_max_ray_len(self): if hasattr(self, '_m_has_field_max_ray_len'): return self._m_has_field_max_ray_len self._m_has_field_max_ray_len = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_ray_len', None) @property def has_field_debug(self): if hasattr(self, '_m_has_field_debug'): return self._m_has_field_debug self._m_has_field_debug = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_debug', None) @property def has_field_label_map(self): if hasattr(self, '_m_has_field_label_map'): return self._m_has_field_label_map self._m_has_field_label_map = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_label_map', None) @property def has_field_ray_cast_per_frame(self): if hasattr(self, '_m_has_field_ray_cast_per_frame'): return self._m_has_field_ray_cast_per_frame self._m_has_field_ray_cast_per_frame = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ray_cast_per_frame', None) @property def has_field_default_sampling_level(self): if hasattr(self, '_m_has_field_default_sampling_level'): return self._m_has_field_default_sampling_level self._m_has_field_default_sampling_level = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_sampling_level', None) @property def has_field_openness_func_type(self): if hasattr(self, '_m_has_field_openness_func_type'): return self._m_has_field_openness_func_type self._m_has_field_openness_func_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_openness_func_type', None) class FishStockTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlitzRushParkourExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetMpSupportMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_succ_actions: self.succ_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_succ_actions(self): if hasattr(self, '_m_has_field_succ_actions'): return self._m_has_field_succ_actions self._m_has_field_succ_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_succ_actions', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fail_actions', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicNegativeCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_inner_id: self.inner_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_inner_id(self): if hasattr(self, '_m_has_field_inner_id'): return self._m_has_field_inner_id self._m_has_field_inner_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_inner_id', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ByHasShieldV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ByHasShield(self._io, self, self._root) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def use_potent_shield(self): if hasattr(self, '_m_use_potent_shield'): return self._m_use_potent_shield self._m_use_potent_shield = self.base.use_potent_shield return getattr(self, '_m_use_potent_shield', None) @property def potent_shield_type(self): if hasattr(self, '_m_potent_shield_type'): return self._m_potent_shield_type self._m_potent_shield_type = self.base.potent_shield_type return getattr(self, '_m_potent_shield_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActivitySalesmanRewardMatchConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reourece_type: self.reourece_type = Output.EnumRewardResourceType(self._io, self, self._root) if self.has_field_box_name: self.box_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_reourece_type(self): if hasattr(self, '_m_has_field_reourece_type'): return self._m_has_field_reourece_type self._m_has_field_reourece_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reourece_type', None) @property def has_field_box_name(self): if hasattr(self, '_m_has_field_box_name'): return self._m_has_field_box_name self._m_has_field_box_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_box_name', None) class LanV2projectionRootPointMotionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RefreshTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAnimatorBoolLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AnimatorBool(self._io, self, self._root)) class DocumentExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigJudgeGroupEntityLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigJudgeGroupEntity(self._io, self, self._root)) class DispConfigBaseWidget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigWidgetWaterSprite(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigWidgetGadgetBuilder(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigWidgetOpenPage(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBaseWidget(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigWidgetLunchBox(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigWidgetClientDetector(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigWidgetAddBuffToy(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigWidgetClientCollector(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigWidgetAnchorPoint(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigWidgetMiracleRing(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigWidgetTakePhoto(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigWidgetBlessingCamera(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigWidgetCondenseResin(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigWidgetOneoffGatherPointDetector(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigWidgetUseItemToy(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigWidgetWaterSpriteToy(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigWidgetAttachAvatar(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigWidgetTreasureMapDetector(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigWidgetAbilityGroupGenerator(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigWidgetUseAttachAbilityGroupToy(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigWidgetBonfire(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ApplyModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class BlitzRushExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_duration: self.content_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_reward_id: self.dungeon_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_pre_quest_id: self.pre_pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hide_oath_entrance: self.hide_oath_entrance = self._io.read_u1() @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_dungeon_reward_id(self): if hasattr(self, '_m_has_field_dungeon_reward_id'): return self._m_has_field_dungeon_reward_id self._m_has_field_dungeon_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_dungeon_reward_id', None) @property def has_field_content_duration(self): if hasattr(self, '_m_has_field_content_duration'): return self._m_has_field_content_duration self._m_has_field_content_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content_duration', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_pre_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_pre_quest_id'): return self._m_has_field_pre_pre_quest_id self._m_has_field_pre_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_pre_pre_quest_id', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_hide_oath_entrance(self): if hasattr(self, '_m_has_field_hide_oath_entrance'): return self._m_has_field_hide_oath_entrance self._m_has_field_hide_oath_entrance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_hide_oath_entrance', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class ArrayOfConfigAnimatorFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAnimatorFloat(self._io, self, self._root)) class EmbeddedTextMapConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_text_map_id: self.text_map_id = AuxTypes.String(self._io, self, self._root) if self.has_field_text_map_content: self.text_map_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_text_map_id(self): if hasattr(self, '_m_has_field_text_map_id'): return self._m_has_field_text_map_id self._m_has_field_text_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_text_map_id', None) @property def has_field_text_map_content(self): if hasattr(self, '_m_has_field_text_map_content'): return self._m_has_field_text_map_content self._m_has_field_text_map_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_text_map_content', None) class InterActionTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LevelTagResetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series_id_list: self.series_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_series_id_list(self): if hasattr(self, '_m_has_field_series_id_list'): return self._m_has_field_series_id_list self._m_has_field_series_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_series_id_list', None) class ArrayOfConfigRaycastLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRaycast(self._io, self, self._root)) class TowerLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfBoolItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfBoolItemOptionArrayInfo(self._io, self, self._root) class EnumColliderTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ColliderTriggerType, self.data.value) return getattr(self, '_m_value', None) class LanV2fireworksStageDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumVehicleLimitType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VehicleLimitType, self.data.value) return getattr(self, '_m_value', None) class NativeVectorNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDirectionAngleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DirectionAngleType, self.data.value) return getattr(self, '_m_value', None) class HomeWorldExtraFurnitureExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_data: self.extra_data = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_extra_data(self): if hasattr(self, '_m_has_field_extra_data'): return self._m_has_field_extra_data self._m_has_field_extra_data = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_extra_data', None) class DictOfAuxTypesStringArrayOfEnumNeuronNameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfEnumNeuronNameLengthU(self._io, self, self._root)) class EntityMarkShowTypeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mark_type: self.mark_type = Output.EnumEntityMarkType(self._io, self, self._root) @property def has_field_mark_type(self): if hasattr(self, '_m_has_field_mark_type'): return self._m_has_field_mark_type self._m_has_field_mark_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mark_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class GivingMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShoot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bullet_born_attach_point: self.bullet_born_attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_detect_range_from_viewport: self.detect_range_from_viewport = self._io.read_f4le() if self.has_field_detect_radius_from_viewport: self.detect_radius_from_viewport = self._io.read_f4le() if self.has_field_auto_focus_min_range: self.auto_focus_min_range = self._io.read_f4le() if self.has_field_auto_focus_max_range: self.auto_focus_max_range = self._io.read_f4le() @property def has_field_bullet_born_attach_point(self): if hasattr(self, '_m_has_field_bullet_born_attach_point'): return self._m_has_field_bullet_born_attach_point self._m_has_field_bullet_born_attach_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bullet_born_attach_point', None) @property def has_field_auto_focus_min_range(self): if hasattr(self, '_m_has_field_auto_focus_min_range'): return self._m_has_field_auto_focus_min_range self._m_has_field_auto_focus_min_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_auto_focus_min_range', None) @property def has_field_detect_range_from_viewport(self): if hasattr(self, '_m_has_field_detect_range_from_viewport'): return self._m_has_field_detect_range_from_viewport self._m_has_field_detect_range_from_viewport = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_range_from_viewport', None) @property def has_field_detect_radius_from_viewport(self): if hasattr(self, '_m_has_field_detect_radius_from_viewport'): return self._m_has_field_detect_radius_from_viewport self._m_has_field_detect_radius_from_viewport = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_detect_radius_from_viewport', None) @property def has_field_auto_focus_max_range(self): if hasattr(self, '_m_has_field_auto_focus_max_range'): return self._m_has_field_auto_focus_max_range self._m_has_field_auto_focus_max_range = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_auto_focus_max_range', None) class ConfigLocalEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_check_dist: self.check_dist = self._io.read_f4le() if self.has_field_with_go: self.with_go = self._io.read_u1() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_with_go(self): if hasattr(self, '_m_has_field_with_go'): return self._m_has_field_with_go self._m_has_field_with_go = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_with_go', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_check_dist(self): if hasattr(self, '_m_has_field_check_dist'): return self._m_has_field_check_dist self._m_has_field_check_dist = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_check_dist', None) class QuestSummarizationTextExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) class QuestExecTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LampPhaseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetUiCombatBarSpark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesVlqBase128LeUConfigResourceCollectionContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigResourceCollectionContent(self._io, self, self._root)) class RelationalOperatorComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElectricCoreMoveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_once_velocity: self.stage_once_velocity = self._io.read_f4le() if self.has_field_stage_one_accelerate: self.stage_one_accelerate = self._io.read_f4le() if self.has_field_stage_two_velocity: self.stage_two_velocity = self._io.read_f4le() if self.has_field_stage_two_attenuation: self.stage_two_attenuation = self._io.read_f4le() if self.has_field_max_absorb_time: self.max_absorb_time = self._io.read_f4le() if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_on_core_enter: self.on_core_enter = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_interrupted: self.on_interrupted = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_start_success: self.on_start_success = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_start_failed: self.on_start_failed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_core_enter(self): if hasattr(self, '_m_has_field_on_core_enter'): return self._m_has_field_on_core_enter self._m_has_field_on_core_enter = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_core_enter', None) @property def has_field_on_start_failed(self): if hasattr(self, '_m_has_field_on_start_failed'): return self._m_has_field_on_start_failed self._m_has_field_on_start_failed = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_on_start_failed', None) @property def has_field_stage_two_velocity(self): if hasattr(self, '_m_has_field_stage_two_velocity'): return self._m_has_field_stage_two_velocity self._m_has_field_stage_two_velocity = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_stage_two_velocity', None) @property def has_field_stage_two_attenuation(self): if hasattr(self, '_m_has_field_stage_two_attenuation'): return self._m_has_field_stage_two_attenuation self._m_has_field_stage_two_attenuation = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_stage_two_attenuation', None) @property def has_field_on_start_success(self): if hasattr(self, '_m_has_field_on_start_success'): return self._m_has_field_on_start_success self._m_has_field_on_start_success = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_on_start_success', None) @property def has_field_on_interrupted(self): if hasattr(self, '_m_has_field_on_interrupted'): return self._m_has_field_on_interrupted self._m_has_field_on_interrupted = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_interrupted', None) @property def has_field_stage_once_velocity(self): if hasattr(self, '_m_has_field_stage_once_velocity'): return self._m_has_field_stage_once_velocity self._m_has_field_stage_once_velocity = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_stage_once_velocity', None) @property def has_field_max_absorb_time(self): if hasattr(self, '_m_has_field_max_absorb_time'): return self._m_has_field_max_absorb_time self._m_has_field_max_absorb_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_max_absorb_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_stage_one_accelerate(self): if hasattr(self, '_m_has_field_stage_one_accelerate'): return self._m_has_field_stage_one_accelerate self._m_has_field_stage_one_accelerate = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_stage_one_accelerate', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_to_pos', None) class ConfigAiSpacialAdjustSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSpacialAdjustData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSpacialAdjustData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ArrayOfConfigAbilityDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAbilityData(self._io, self, self._root)) class SetTargetNumToGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_src_target: self.src_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_src_other_targets: self.src_other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_src_predicates: self.src_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_dst_target: self.dst_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_dst_other_targets: self.dst_other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_dst_predicates: self.dst_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_dst_predicates(self): if hasattr(self, '_m_has_field_dst_predicates'): return self._m_has_field_dst_predicates self._m_has_field_dst_predicates = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_dst_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_dst_target(self): if hasattr(self, '_m_has_field_dst_target'): return self._m_has_field_dst_target self._m_has_field_dst_target = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_dst_target', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_dst_other_targets(self): if hasattr(self, '_m_has_field_dst_other_targets'): return self._m_has_field_dst_other_targets self._m_has_field_dst_other_targets = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_dst_other_targets', None) @property def has_field_src_other_targets(self): if hasattr(self, '_m_has_field_src_other_targets'): return self._m_has_field_src_other_targets self._m_has_field_src_other_targets = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_src_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_src_target(self): if hasattr(self, '_m_has_field_src_target'): return self._m_has_field_src_target self._m_has_field_src_target = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_src_target', None) @property def has_field_src_predicates(self): if hasattr(self, '_m_has_field_src_predicates'): return self._m_has_field_src_predicates self._m_has_field_src_predicates = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_src_predicates', None) class ConfigGadgetPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gadget_paths: self.gadget_paths = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_gadget_paths(self): if hasattr(self, '_m_has_field_gadget_paths'): return self._m_has_field_gadget_paths self._m_has_field_gadget_paths = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_paths', None) class TriggerBullet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bullet_id: self.bullet_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_owner_is_target: self.owner_is_target = self._io.read_u1() if self.has_field_owner_is: self.owner_is = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_prop_owner_is: self.prop_owner_is = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_life_by_owner_is_alive: self.life_by_owner_is_alive = self._io.read_u1() if self.has_field_track_target: self.track_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_track_target_list: self.track_target_list = Output.ArrayOfSingleTargetLengthU(self._io, self, self._root) if self.has_field_sight_group_with_owner: self.sight_group_with_owner = self._io.read_u1() if self.has_field_is_peer_id_from_player: self.is_peer_id_from_player = self._io.read_u1() if self.has_field_life_by_owner_v2: self.life_by_owner_v2 = self._io.read_u1() if self.has_field_dont_kill_self_by_client_prediction: self.dont_kill_self_by_client_prediction = self._io.read_u1() @property def has_field_sight_group_with_owner(self): if hasattr(self, '_m_has_field_sight_group_with_owner'): return self._m_has_field_sight_group_with_owner self._m_has_field_sight_group_with_owner = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_sight_group_with_owner', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_owner_is(self): if hasattr(self, '_m_has_field_owner_is'): return self._m_has_field_owner_is self._m_has_field_owner_is = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_owner_is', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_track_target_list(self): if hasattr(self, '_m_has_field_track_target_list'): return self._m_has_field_track_target_list self._m_has_field_track_target_list = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_track_target_list', None) @property def has_field_life_by_owner_v2(self): if hasattr(self, '_m_has_field_life_by_owner_v2'): return self._m_has_field_life_by_owner_v2 self._m_has_field_life_by_owner_v2 = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_life_by_owner_v2', None) @property def has_field_life_by_owner_is_alive(self): if hasattr(self, '_m_has_field_life_by_owner_is_alive'): return self._m_has_field_life_by_owner_is_alive self._m_has_field_life_by_owner_is_alive = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_life_by_owner_is_alive', None) @property def has_field_bullet_id(self): if hasattr(self, '_m_has_field_bullet_id'): return self._m_has_field_bullet_id self._m_has_field_bullet_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_bullet_id', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_track_target(self): if hasattr(self, '_m_has_field_track_target'): return self._m_has_field_track_target self._m_has_field_track_target = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_track_target', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_is_peer_id_from_player(self): if hasattr(self, '_m_has_field_is_peer_id_from_player'): return self._m_has_field_is_peer_id_from_player self._m_has_field_is_peer_id_from_player = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_is_peer_id_from_player', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_dont_kill_self_by_client_prediction(self): if hasattr(self, '_m_has_field_dont_kill_self_by_client_prediction'): return self._m_has_field_dont_kill_self_by_client_prediction self._m_has_field_dont_kill_self_by_client_prediction = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_dont_kill_self_by_client_prediction', None) @property def has_field_prop_owner_is(self): if hasattr(self, '_m_has_field_prop_owner_is'): return self._m_has_field_prop_owner_is self._m_has_field_prop_owner_is = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_prop_owner_is', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_owner_is_target(self): if hasattr(self, '_m_has_field_owner_is_target'): return self._m_has_field_owner_is_target self._m_has_field_owner_is_target = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_owner_is_target', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_born', None) class EnumModifierStacking(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ModifierStacking, self.data.value) return getattr(self, '_m_value', None) class ConfigElementDecrate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_elem1: self.elem1 = Output.EnumElementType(self._io, self, self._root) if self.has_field_elem2: self.elem2 = Output.EnumElementType(self._io, self, self._root) if self.has_field_ratio: self.ratio = self._io.read_f4le() @property def has_field_elem1(self): if hasattr(self, '_m_has_field_elem1'): return self._m_has_field_elem1 self._m_has_field_elem1 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_elem1', None) @property def has_field_elem2(self): if hasattr(self, '_m_has_field_elem2'): return self._m_has_field_elem2 self._m_has_field_elem2 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_elem2', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ratio', None) class ChessCardNumericalModificationModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigKeyboardLayoutItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_key_code_friendly_name: self.key_code_friendly_name = Output.DictOfEnumConfigKeyCodeAuxTypesString(self._io, self, self._root) @property def has_field_key_code_friendly_name(self): if hasattr(self, '_m_has_field_key_code_friendly_name'): return self._m_has_field_key_code_friendly_name self._m_has_field_key_code_friendly_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key_code_friendly_name', None) class ReplaceEventPatternMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_old_patterns: self.old_patterns = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_new_patterns: self.new_patterns = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_old_patterns(self): if hasattr(self, '_m_has_field_old_patterns'): return self._m_has_field_old_patterns self._m_has_field_old_patterns = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_old_patterns', None) @property def has_field_new_patterns(self): if hasattr(self, '_m_has_field_new_patterns'): return self._m_has_field_new_patterns self._m_has_field_new_patterns = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_new_patterns', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigBornByHitPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class CurtainTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMusicBehaviourIgnorance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MusicBehaviourIgnorance, self.data.value) return getattr(self, '_m_value', None) class ReunionMissionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairTipsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) class ByAvatarInWaterDepth(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) if self.has_field_depth: self.depth = self._io.read_f4le() @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_compare_type', None) @property def has_field_depth(self): if hasattr(self, '_m_has_field_depth'): return self._m_has_field_depth self._m_has_field_depth = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_depth', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigGadgetCameraBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_name: self.config_name = AuxTypes.String(self._io, self, self._root) if self.has_field_enter_radius: self.enter_radius = self._io.read_f4le() if self.has_field_exit_radius: self.exit_radius = self._io.read_f4le() if self.has_field_ui_action: self.ui_action = Output.EnumGadgetCameraBoxUiActionType(self._io, self, self._root) @property def has_field_config_name(self): if hasattr(self, '_m_has_field_config_name'): return self._m_has_field_config_name self._m_has_field_config_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_name', None) @property def has_field_enter_radius(self): if hasattr(self, '_m_has_field_enter_radius'): return self._m_has_field_enter_radius self._m_has_field_enter_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enter_radius', None) @property def has_field_exit_radius(self): if hasattr(self, '_m_has_field_exit_radius'): return self._m_has_field_exit_radius self._m_has_field_exit_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_exit_radius', None) @property def has_field_ui_action(self): if hasattr(self, '_m_has_field_ui_action'): return self._m_has_field_ui_action self._m_has_field_ui_action = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ui_action', None) class DispDebugBlletinInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.DebugBlletinInfo(self._io, self, self._root) elif _on == 1: self.data = Output.DebugBoardInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigJudgeGroupEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_group_entity_type: self.group_entity_type = Output.EnumGroupEntityType(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_group_entity_type(self): if hasattr(self, '_m_has_field_group_entity_type'): return self._m_has_field_group_entity_type self._m_has_field_group_entity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_entity_type', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_config_id', None) class ExpeditionDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_hours: self.need_hours = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_player: self.min_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_player: self.max_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_refresh_count: self.min_refresh_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_refresh_count: self.max_refresh_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coef: self.coef = self._io.read_f4le() @property def has_field_min_player(self): if hasattr(self, '_m_has_field_min_player'): return self._m_has_field_min_player self._m_has_field_min_player = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_min_player', None) @property def has_field_min_refresh_count(self): if hasattr(self, '_m_has_field_min_refresh_count'): return self._m_has_field_min_refresh_count self._m_has_field_min_refresh_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_min_refresh_count', None) @property def has_field_max_player(self): if hasattr(self, '_m_has_field_max_player'): return self._m_has_field_max_player self._m_has_field_max_player = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_player', None) @property def has_field_coef(self): if hasattr(self, '_m_has_field_coef'): return self._m_has_field_coef self._m_has_field_coef = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_coef', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_need_hours(self): if hasattr(self, '_m_has_field_need_hours'): return self._m_has_field_need_hours self._m_has_field_need_hours = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_need_hours', None) @property def has_field_max_refresh_count(self): if hasattr(self, '_m_has_field_max_refresh_count'): return self._m_has_field_max_refresh_count self._m_has_field_max_refresh_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_max_refresh_count', None) class ArrayOfDispConfigBaseGuideLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBaseGuide(self._io, self, self._root)) class ArrayOfConfigSpatialSphereRoomTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSpatialSphereRoomTrigger(self._io, self, self._root)) class ConfigEliteShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = AuxTypes.String(self._io, self, self._root) if self.has_field_damage_ratio: self.damage_ratio = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_damage_suffer_ratio: self.damage_suffer_ratio = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_damage_ratio(self): if hasattr(self, '_m_has_field_damage_ratio'): return self._m_has_field_damage_ratio self._m_has_field_damage_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_damage_ratio', None) @property def has_field_damage_suffer_ratio(self): if hasattr(self, '_m_has_field_damage_suffer_ratio'): return self._m_has_field_damage_suffer_ratio self._m_has_field_damage_suffer_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_damage_suffer_ratio', None) class MechanicusMapPointExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUAdaptiveParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUAdaptiveParam(self._io, self, self._root)) class KvpOfDictAuxTypesStringDispContextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispContextAction(self._io, self, self._root) class InteractCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SendEvtElectricCoreMoveEnterP1(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigEffectAttachMesh(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEffectAttachShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mesh: self.mesh = AuxTypes.String(self._io, self, self._root) @property def has_field_mesh(self): if hasattr(self, '_m_has_field_mesh'): return self._m_has_field_mesh self._m_has_field_mesh = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mesh', None) class RogueDiaryPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringDispConfigScenePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigScenePoint(self._io, self, self._root)) class ConfigMusicSingleLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ArrayOfConfigAiMixinSetControllerConditionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetControllerCondition(self._io, self, self._root)) class EnumGeneralRoutineType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GeneralRoutineType, self.data.value) return getattr(self, '_m_value', None) class ConfigMoveVelocityForce(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_mute_all: self.mute_all = self._io.read_u1() if self.has_field_use_all: self.use_all = self._io.read_u1() if self.has_field_include_forces: self.include_forces = Output.ArrayOfEnumVelocityForceTypeLengthU(self._io, self, self._root) if self.has_field_exclude_forces: self.exclude_forces = Output.ArrayOfEnumVelocityForceTypeLengthU(self._io, self, self._root) @property def has_field_mute_all(self): if hasattr(self, '_m_has_field_mute_all'): return self._m_has_field_mute_all self._m_has_field_mute_all = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mute_all', None) @property def has_field_use_all(self): if hasattr(self, '_m_has_field_use_all'): return self._m_has_field_use_all self._m_has_field_use_all = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_all', None) @property def has_field_include_forces(self): if hasattr(self, '_m_has_field_include_forces'): return self._m_has_field_include_forces self._m_has_field_include_forces = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_include_forces', None) @property def has_field_exclude_forces(self): if hasattr(self, '_m_has_field_exclude_forces'): return self._m_has_field_exclude_forces self._m_has_field_exclude_forces = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_exclude_forces', None) class FireEffectToTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_reverse: self.reverse = self._io.read_u1() if self.has_field_from_self: self.from_self = self._io.read_u1() if self.has_field_scale: self.scale = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_reverse(self): if hasattr(self, '_m_has_field_reverse'): return self._m_has_field_reverse self._m_has_field_reverse = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reverse', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_from_self(self): if hasattr(self, '_m_has_field_from_self'): return self._m_has_field_from_self self._m_has_field_from_self = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_from_self', None) class ChannellerSlabLoopDungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id_vec: self.monster_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_limiting_condition_vec: self.limiting_condition_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_first_pass_reward_id: self.first_pass_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_first_pass_reward_id(self): if hasattr(self, '_m_has_field_first_pass_reward_id'): return self._m_has_field_first_pass_reward_id self._m_has_field_first_pass_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_first_pass_reward_id', None) @property def has_field_monster_id_vec(self): if hasattr(self, '_m_has_field_monster_id_vec'): return self._m_has_field_monster_id_vec self._m_has_field_monster_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_id_vec', None) @property def has_field_limiting_condition_vec(self): if hasattr(self, '_m_has_field_limiting_condition_vec'): return self._m_has_field_limiting_condition_vec self._m_has_field_limiting_condition_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_limiting_condition_vec', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_content', None) class CustomLevelTagConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumWorldAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WorldAreaType, self.data.value) return getattr(self, '_m_value', None) class FocusAssistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_use_focus_sticky: self.use_focus_sticky = self._io.read_u1() if self.has_field_use_auto_focus: self.use_auto_focus = self._io.read_u1() if self.has_field_use_gyro: self.use_gyro = self._io.read_u1() @property def has_field_use_focus_sticky(self): if hasattr(self, '_m_has_field_use_focus_sticky'): return self._m_has_field_use_focus_sticky self._m_has_field_use_focus_sticky = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_focus_sticky', None) @property def has_field_use_auto_focus(self): if hasattr(self, '_m_has_field_use_auto_focus'): return self._m_has_field_use_auto_focus self._m_has_field_use_auto_focus = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_auto_focus', None) @property def has_field_use_gyro(self): if hasattr(self, '_m_has_field_use_gyro'): return self._m_has_field_use_gyro self._m_has_field_use_gyro = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_gyro', None) class InteractTriggerAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DispConfigMultiBullet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigMultiBullet(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigEffectItanoCircusBullet(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class RoguelikeShikigamiUnlockTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigQuestScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_id: self.sub_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_id: self.main_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_sub_id_set: self.sub_id_set = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_mp_block: self.is_mp_block = self._io.read_u1() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_step_desc: self.step_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_tips: self.guide_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_ban_type: self.ban_type = Output.EnumBanGroupType(self._io, self, self._root) if self.has_field_accept_cond_comb: self.accept_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_accept_cond: self.accept_cond = Output.ArrayOfQuestCondExLengthU(self._io, self, self._root) if self.has_field_finish_cond_comb: self.finish_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_finish_cond: self.finish_cond = Output.ArrayOfQuestContentExLengthU(self._io, self, self._root) if self.has_field_fail_cond_comb: self.fail_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_fail_cond: self.fail_cond = Output.ArrayOfQuestContentExLengthU(self._io, self, self._root) if self.has_field_guide: self.guide = Output.QuestGuideEx(self._io, self, self._root) if self.has_field_show_guide: self.show_guide = Output.EnumShowQuestGuideType(self._io, self, self._root) if self.has_field_finish_parent: self.finish_parent = self._io.read_u1() if self.has_field_fail_parent: self.fail_parent = self._io.read_u1() if self.has_field_fail_parent_show: self.fail_parent_show = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_is_rewind: self.is_rewind = self._io.read_u1() if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfQuestExecExLengthU(self._io, self, self._root) if self.has_field_fail_exec: self.fail_exec = Output.ArrayOfQuestExecExLengthU(self._io, self, self._root) if self.has_field_begin_exec: self.begin_exec = Output.ArrayOfQuestExecExLengthU(self._io, self, self._root) if self.has_field_exclusive_npc_list: self.exclusive_npc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exclusive_place_list: self.exclusive_place_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_shared_npc_list: self.shared_npc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exclusive_npc_priority: self.exclusive_npc_priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_version_begin: self.version_begin = AuxTypes.String(self._io, self, self._root) if self.has_field_version_end: self.version_end = AuxTypes.String(self._io, self, self._root) @property def has_field_finish_cond(self): if hasattr(self, '_m_has_field_finish_cond'): return self._m_has_field_finish_cond self._m_has_field_finish_cond = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_finish_cond', None) @property def has_field_version_end(self): if hasattr(self, '_m_has_field_version_end'): return self._m_has_field_version_end self._m_has_field_version_end = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_version_end', None) @property def has_field_ban_type(self): if hasattr(self, '_m_has_field_ban_type'): return self._m_has_field_ban_type self._m_has_field_ban_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_ban_type', None) @property def has_field_fail_cond(self): if hasattr(self, '_m_has_field_fail_cond'): return self._m_has_field_fail_cond self._m_has_field_fail_cond = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_fail_cond', None) @property def has_field_is_rewind(self): if hasattr(self, '_m_has_field_is_rewind'): return self._m_has_field_is_rewind self._m_has_field_is_rewind = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_is_rewind', None) @property def has_field_is_mp_block(self): if hasattr(self, '_m_has_field_is_mp_block'): return self._m_has_field_is_mp_block self._m_has_field_is_mp_block = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_is_mp_block', None) @property def has_field_finish_cond_comb(self): if hasattr(self, '_m_has_field_finish_cond_comb'): return self._m_has_field_finish_cond_comb self._m_has_field_finish_cond_comb = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_finish_cond_comb', None) @property def has_field_exclusive_place_list(self): if hasattr(self, '_m_has_field_exclusive_place_list'): return self._m_has_field_exclusive_place_list self._m_has_field_exclusive_place_list = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_exclusive_place_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_desc', None) @property def has_field_version_begin(self): if hasattr(self, '_m_has_field_version_begin'): return self._m_has_field_version_begin self._m_has_field_version_begin = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_version_begin', None) @property def has_field_step_desc(self): if hasattr(self, '_m_has_field_step_desc'): return self._m_has_field_step_desc self._m_has_field_step_desc = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_step_desc', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_finish_exec', None) @property def has_field_accept_cond_comb(self): if hasattr(self, '_m_has_field_accept_cond_comb'): return self._m_has_field_accept_cond_comb self._m_has_field_accept_cond_comb = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_accept_cond_comb', None) @property def has_field_main_id(self): if hasattr(self, '_m_has_field_main_id'): return self._m_has_field_main_id self._m_has_field_main_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_main_id', None) @property def has_field_sub_id_set(self): if hasattr(self, '_m_has_field_sub_id_set'): return self._m_has_field_sub_id_set self._m_has_field_sub_id_set = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_sub_id_set', None) @property def has_field_fail_parent(self): if hasattr(self, '_m_has_field_fail_parent'): return self._m_has_field_fail_parent self._m_has_field_fail_parent = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_fail_parent', None) @property def has_field_fail_cond_comb(self): if hasattr(self, '_m_has_field_fail_cond_comb'): return self._m_has_field_fail_cond_comb self._m_has_field_fail_cond_comb = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_fail_cond_comb', None) @property def has_field_guide(self): if hasattr(self, '_m_has_field_guide'): return self._m_has_field_guide self._m_has_field_guide = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_guide', None) @property def has_field_shared_npc_list(self): if hasattr(self, '_m_has_field_shared_npc_list'): return self._m_has_field_shared_npc_list self._m_has_field_shared_npc_list = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_shared_npc_list', None) @property def has_field_exclusive_npc_priority(self): if hasattr(self, '_m_has_field_exclusive_npc_priority'): return self._m_has_field_exclusive_npc_priority self._m_has_field_exclusive_npc_priority = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_exclusive_npc_priority', None) @property def has_field_show_guide(self): if hasattr(self, '_m_has_field_show_guide'): return self._m_has_field_show_guide self._m_has_field_show_guide = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_show_guide', None) @property def has_field_begin_exec(self): if hasattr(self, '_m_has_field_begin_exec'): return self._m_has_field_begin_exec self._m_has_field_begin_exec = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_begin_exec', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_show_type', None) @property def has_field_sub_id(self): if hasattr(self, '_m_has_field_sub_id'): return self._m_has_field_sub_id self._m_has_field_sub_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_sub_id', None) @property def has_field_fail_exec(self): if hasattr(self, '_m_has_field_fail_exec'): return self._m_has_field_fail_exec self._m_has_field_fail_exec = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_fail_exec', None) @property def has_field_accept_cond(self): if hasattr(self, '_m_has_field_accept_cond'): return self._m_has_field_accept_cond self._m_has_field_accept_cond = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_accept_cond', None) @property def has_field_guide_tips(self): if hasattr(self, '_m_has_field_guide_tips'): return self._m_has_field_guide_tips self._m_has_field_guide_tips = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_guide_tips', None) @property def has_field_fail_parent_show(self): if hasattr(self, '_m_has_field_fail_parent_show'): return self._m_has_field_fail_parent_show self._m_has_field_fail_parent_show = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_fail_parent_show', None) @property def has_field_exclusive_npc_list(self): if hasattr(self, '_m_has_field_exclusive_npc_list'): return self._m_has_field_exclusive_npc_list self._m_has_field_exclusive_npc_list = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_exclusive_npc_list', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_order', None) @property def has_field_finish_parent(self): if hasattr(self, '_m_has_field_finish_parent'): return self._m_has_field_finish_parent self._m_has_field_finish_parent = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_finish_parent', None) class PreviewActivityCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_condtion_id: self.condtion_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.String(self._io, self, self._root) @property def has_field_condtion_id(self): if hasattr(self, '_m_has_field_condtion_id'): return self._m_has_field_condtion_id self._m_has_field_condtion_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_condtion_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) class DictOfAuxTypesVlqBase128LeSConfigAiFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFacingMoveData(self._io, self, self._root)) class MpPlayBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ManualTextMapConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachAbilityStateResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_resistance_list_id: self.resistance_list_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resistance_buff_debuffs: self.resistance_buff_debuffs = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) if self.has_field_duration_ratio: self.duration_ratio = self._io.read_f4le() @property def has_field_resistance_buff_debuffs(self): if hasattr(self, '_m_has_field_resistance_buff_debuffs'): return self._m_has_field_resistance_buff_debuffs self._m_has_field_resistance_buff_debuffs = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_resistance_buff_debuffs', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_resistance_list_id(self): if hasattr(self, '_m_has_field_resistance_list_id'): return self._m_has_field_resistance_list_id self._m_has_field_resistance_list_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_resistance_list_id', None) @property def has_field_duration_ratio(self): if hasattr(self, '_m_has_field_duration_ratio'): return self._m_has_field_duration_ratio self._m_has_field_duration_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumPsActivitiesCategoryType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PsActivitiesCategoryType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEntityAudio(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_triggers_speech: self.triggers_speech = self._io.read_u1() @property def has_field_triggers_speech(self): if hasattr(self, '_m_has_field_triggers_speech'): return self._m_has_field_triggers_speech self._m_has_field_triggers_speech = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_triggers_speech', None) @property def destroy_event(self): if hasattr(self, '_m_destroy_event'): return self._m_destroy_event self._m_destroy_event = self.base.destroy_event return getattr(self, '_m_destroy_event', None) @property def anim_audio(self): if hasattr(self, '_m_anim_audio'): return self._m_anim_audio self._m_anim_audio = self.base.anim_audio return getattr(self, '_m_anim_audio', None) @property def disable_event(self): if hasattr(self, '_m_disable_event'): return self._m_disable_event self._m_disable_event = self.base.disable_event return getattr(self, '_m_disable_event', None) @property def enable_event(self): if hasattr(self, '_m_enable_event'): return self._m_enable_event self._m_enable_event = self.base.enable_event return getattr(self, '_m_enable_event', None) @property def init_event(self): if hasattr(self, '_m_init_event'): return self._m_init_event self._m_init_event = self.base.init_event return getattr(self, '_m_init_event', None) class ActivitySkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_target: self.skill_target = Output.EnumActivitySkillTarget(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_energy_min: self.energy_min = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_energy_max: self.energy_max = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_time: self.cd_time = self._io.read_f4le() if self.has_field_guide_time: self.guide_time = self._io.read_f4le() if self.has_field_skill_icon: self.skill_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_guide_key: self.guide_key = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_guide_open_state: self.guide_open_state = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_unable_text: self.unable_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_channel_text: self.channel_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_interrupt_text: self.interrupt_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_energy_min(self): if hasattr(self, '_m_has_field_energy_min'): return self._m_has_field_energy_min self._m_has_field_energy_min = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_energy_min', None) @property def has_field_interrupt_text(self): if hasattr(self, '_m_has_field_interrupt_text'): return self._m_has_field_interrupt_text self._m_has_field_interrupt_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_interrupt_text', None) @property def has_field_guide_time(self): if hasattr(self, '_m_has_field_guide_time'): return self._m_has_field_guide_time self._m_has_field_guide_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_guide_time', None) @property def has_field_channel_text(self): if hasattr(self, '_m_has_field_channel_text'): return self._m_has_field_channel_text self._m_has_field_channel_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_channel_text', None) @property def has_field_guide_key(self): if hasattr(self, '_m_has_field_guide_key'): return self._m_has_field_guide_key self._m_has_field_guide_key = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_guide_key', None) @property def has_field_guide_open_state(self): if hasattr(self, '_m_has_field_guide_open_state'): return self._m_has_field_guide_open_state self._m_has_field_guide_open_state = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_guide_open_state', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_energy_max(self): if hasattr(self, '_m_has_field_energy_max'): return self._m_has_field_energy_max self._m_has_field_energy_max = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_energy_max', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_cd_time(self): if hasattr(self, '_m_has_field_cd_time'): return self._m_has_field_cd_time self._m_has_field_cd_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cd_time', None) @property def has_field_unable_text(self): if hasattr(self, '_m_has_field_unable_text'): return self._m_has_field_unable_text self._m_has_field_unable_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_unable_text', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_skill_target(self): if hasattr(self, '_m_has_field_skill_target'): return self._m_has_field_skill_target self._m_has_field_skill_target = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_target', None) @property def has_field_skill_icon(self): if hasattr(self, '_m_has_field_skill_icon'): return self._m_has_field_skill_icon self._m_has_field_skill_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_skill_icon', None) class AreaUnlockInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class GuideItemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterActivityPerviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_level: self.unlock_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_reward_id: self.special_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_stay_time: self.activity_stay_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfab_change_quest_id: self.perfab_change_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_special_reward_id(self): if hasattr(self, '_m_has_field_special_reward_id'): return self._m_has_field_special_reward_id self._m_has_field_special_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_special_reward_id', None) @property def has_field_perfab_change_quest_id(self): if hasattr(self, '_m_has_field_perfab_change_quest_id'): return self._m_has_field_perfab_change_quest_id self._m_has_field_perfab_change_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_perfab_change_quest_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_activity_stay_time(self): if hasattr(self, '_m_has_field_activity_stay_time'): return self._m_has_field_activity_stay_time self._m_has_field_activity_stay_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_activity_stay_time', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_unlock_level(self): if hasattr(self, '_m_has_field_unlock_level'): return self._m_has_field_unlock_level self._m_has_field_unlock_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_level', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigHomeworldBlockAutoGen(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_block_id: self.block_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_pos: self.center_pos = Output.Vector(self._io, self, self._root) if self.has_field_center_rot: self.center_rot = Output.Vector(self._io, self, self._root) @property def has_field_block_id(self): if hasattr(self, '_m_has_field_block_id'): return self._m_has_field_block_id self._m_has_field_block_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_block_id', None) @property def has_field_center_pos(self): if hasattr(self, '_m_has_field_center_pos'): return self._m_has_field_center_pos self._m_has_field_center_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_center_pos', None) @property def has_field_center_rot(self): if hasattr(self, '_m_has_field_center_rot'): return self._m_has_field_center_rot self._m_has_field_center_rot = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_center_rot', None) class ConfigAiSpacialFacingMoveSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSpacialFacingMoveData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSpacialFacingMoveData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class RogueGadgetStateConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumRogueGadgetStateType(self._io, self, self._root) if self.has_field_gadget_state: self.gadget_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_state', None) @property def has_field_gadget_state(self): if hasattr(self, '_m_has_field_gadget_state'): return self._m_has_field_gadget_state self._m_has_field_gadget_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_state', None) class ConfigDummyAbilityOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_disable_apply_modifier_error: self.disable_apply_modifier_error = self._io.read_u1() @property def has_field_disable_apply_modifier_error(self): if hasattr(self, '_m_has_field_disable_apply_modifier_error'): return self._m_has_field_disable_apply_modifier_error self._m_has_field_disable_apply_modifier_error = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_disable_apply_modifier_error', None) class ArrayOfDispIndicatorConditionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispIndicatorCondition(self._io, self, self._root)) class EnumInterTimingType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InterTimingType, self.data.value) return getattr(self, '_m_value', None) class EnumRogueDiaryResourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueDiaryResourceType, self.data.value) return getattr(self, '_m_value', None) class SectrPlatformTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CustomGadgetSlotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumNewActivityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NewActivityType, self.data.value) return getattr(self, '_m_value', None) class AvatarEnterCameraShot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_move_cfg_path: self.camera_move_cfg_path = AuxTypes.String(self._io, self, self._root) if self.has_field_shot_type: self.shot_type = Output.EnumAbilityCameraShotType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_camera_move_cfg_path(self): if hasattr(self, '_m_has_field_camera_move_cfg_path'): return self._m_has_field_camera_move_cfg_path self._m_has_field_camera_move_cfg_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_move_cfg_path', None) @property def has_field_shot_type(self): if hasattr(self, '_m_has_field_shot_type'): return self._m_has_field_shot_type self._m_has_field_shot_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shot_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ReminderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAvatarShoot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_normal_shoot: self.normal_shoot = Output.ConfigShoot(self._io, self, self._root) if self.has_field_aiming_shoot: self.aiming_shoot = Output.ConfigShoot(self._io, self, self._root) @property def has_field_normal_shoot(self): if hasattr(self, '_m_has_field_normal_shoot'): return self._m_has_field_normal_shoot self._m_has_field_normal_shoot = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_normal_shoot', None) @property def has_field_aiming_shoot(self): if hasattr(self, '_m_has_field_aiming_shoot'): return self._m_has_field_aiming_shoot self._m_has_field_aiming_shoot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_aiming_shoot', None) class BartenderMaterialUnlockConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDungeonPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonPlayType, self.data.value) return getattr(self, '_m_value', None) class ConfigGlobalSwitch(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable_multi_player: self.enable_multi_player = self._io.read_u1() if self.has_field_enable_animator_interleave: self.enable_animator_interleave = self._io.read_u1() if self.has_field_enable_mixin_modifier_detach_callback: self.enable_mixin_modifier_detach_callback = self._io.read_u1() if self.has_field_enable_packet_process_time_limit: self.enable_packet_process_time_limit = self._io.read_u1() if self.has_field_enable_ui_temp_fix: self.enable_ui_temp_fix = self._io.read_u1() if self.has_field_enable_equip_data_item_fix: self.enable_equip_data_item_fix = self._io.read_u1() if self.has_field_cache_entity_light_de_active: self.cache_entity_light_de_active = self._io.read_u1() if self.has_field_enablemax_delay_packet_ms: self.enablemax_delay_packet_ms = self._io.read_u1() if self.has_field_max_delay_packet_ms: self.max_delay_packet_ms = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable_force_sync_postion: self.enable_force_sync_postion = self._io.read_u1() if self.has_field_max_force_distance: self.max_force_distance = self._io.read_f4le() if self.has_field_enable_ability_invoke_after_ready: self.enable_ability_invoke_after_ready = self._io.read_u1() @property def has_field_enable_equip_data_item_fix(self): if hasattr(self, '_m_has_field_enable_equip_data_item_fix'): return self._m_has_field_enable_equip_data_item_fix self._m_has_field_enable_equip_data_item_fix = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_enable_equip_data_item_fix', None) @property def has_field_enable_multi_player(self): if hasattr(self, '_m_has_field_enable_multi_player'): return self._m_has_field_enable_multi_player self._m_has_field_enable_multi_player = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_enable_multi_player', None) @property def has_field_max_delay_packet_ms(self): if hasattr(self, '_m_has_field_max_delay_packet_ms'): return self._m_has_field_max_delay_packet_ms self._m_has_field_max_delay_packet_ms = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_max_delay_packet_ms', None) @property def has_field_enable_ui_temp_fix(self): if hasattr(self, '_m_has_field_enable_ui_temp_fix'): return self._m_has_field_enable_ui_temp_fix self._m_has_field_enable_ui_temp_fix = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_enable_ui_temp_fix', None) @property def has_field_enable_ability_invoke_after_ready(self): if hasattr(self, '_m_has_field_enable_ability_invoke_after_ready'): return self._m_has_field_enable_ability_invoke_after_ready self._m_has_field_enable_ability_invoke_after_ready = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_enable_ability_invoke_after_ready', None) @property def has_field_cache_entity_light_de_active(self): if hasattr(self, '_m_has_field_cache_entity_light_de_active'): return self._m_has_field_cache_entity_light_de_active self._m_has_field_cache_entity_light_de_active = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_cache_entity_light_de_active', None) @property def has_field_max_force_distance(self): if hasattr(self, '_m_has_field_max_force_distance'): return self._m_has_field_max_force_distance self._m_has_field_max_force_distance = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_max_force_distance', None) @property def has_field_enable_packet_process_time_limit(self): if hasattr(self, '_m_has_field_enable_packet_process_time_limit'): return self._m_has_field_enable_packet_process_time_limit self._m_has_field_enable_packet_process_time_limit = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_enable_packet_process_time_limit', None) @property def has_field_enable_mixin_modifier_detach_callback(self): if hasattr(self, '_m_has_field_enable_mixin_modifier_detach_callback'): return self._m_has_field_enable_mixin_modifier_detach_callback self._m_has_field_enable_mixin_modifier_detach_callback = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_enable_mixin_modifier_detach_callback', None) @property def has_field_enable_animator_interleave(self): if hasattr(self, '_m_has_field_enable_animator_interleave'): return self._m_has_field_enable_animator_interleave self._m_has_field_enable_animator_interleave = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_enable_animator_interleave', None) @property def has_field_enable_force_sync_postion(self): if hasattr(self, '_m_has_field_enable_force_sync_postion'): return self._m_has_field_enable_force_sync_postion self._m_has_field_enable_force_sync_postion = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_enable_force_sync_postion', None) @property def has_field_enablemax_delay_packet_ms(self): if hasattr(self, '_m_has_field_enablemax_delay_packet_ms'): return self._m_has_field_enablemax_delay_packet_ms self._m_has_field_enablemax_delay_packet_ms = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enablemax_delay_packet_ms', None) class SetNeuronEnable(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_neuron_name: self.neuron_name = Output.EnumNeuronName(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_neuron_name(self): if hasattr(self, '_m_has_field_neuron_name'): return self._m_has_field_neuron_name self._m_has_field_neuron_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_neuron_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfDispConfigBaseInterActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBaseInterAction(self._io, self, self._root)) class WorldExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MapAreaConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumTargetTypeConfigAttackInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumTargetTypeConfigAttackInfo(self._io, self, self._root)) class EnumAbilityTargetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityTargetting, self.data.value) return getattr(self, '_m_value', None) class ConfigEmojiBubbleData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_effects: self.effects = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effects', None) class EchoShellExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_echo_shell_type: self.echo_shell_type = Output.EnumEchoShellType(self._io, self, self._root) if self.has_field_story_id: self.story_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_title: self.voice_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_desc: self.voice_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_list: self.voice_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reminder_list: self.reminder_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_image_path: self.image_path = AuxTypes.String(self._io, self, self._root) if self.has_field_mark_id: self.mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_position: self.mark_position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_mark_tip_title: self.mark_tip_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_tip_content: self.mark_tip_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exclusive_scene_tags: self.exclusive_scene_tags = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_related_dungeon_id: self.related_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_passed_lock_tip: self.dungeon_passed_lock_tip = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_related_dungeon_entry_id: self.related_dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_id: self.order_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_related_dungeon_entry_id_list: self.related_dungeon_entry_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_related_sub_quest_id: self.related_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_voice_list(self): if hasattr(self, '_m_has_field_voice_list'): return self._m_has_field_voice_list self._m_has_field_voice_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_voice_list', None) @property def has_field_related_dungeon_entry_id_list(self): if hasattr(self, '_m_has_field_related_dungeon_entry_id_list'): return self._m_has_field_related_dungeon_entry_id_list self._m_has_field_related_dungeon_entry_id_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_related_dungeon_entry_id_list', None) @property def has_field_echo_shell_type(self): if hasattr(self, '_m_has_field_echo_shell_type'): return self._m_has_field_echo_shell_type self._m_has_field_echo_shell_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_echo_shell_type', None) @property def has_field_mark_tip_content(self): if hasattr(self, '_m_has_field_mark_tip_content'): return self._m_has_field_mark_tip_content self._m_has_field_mark_tip_content = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_mark_tip_content', None) @property def has_field_order_id(self): if hasattr(self, '_m_has_field_order_id'): return self._m_has_field_order_id self._m_has_field_order_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_order_id', None) @property def has_field_story_id(self): if hasattr(self, '_m_has_field_story_id'): return self._m_has_field_story_id self._m_has_field_story_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_story_id', None) @property def has_field_reminder_list(self): if hasattr(self, '_m_has_field_reminder_list'): return self._m_has_field_reminder_list self._m_has_field_reminder_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reminder_list', None) @property def has_field_voice_title(self): if hasattr(self, '_m_has_field_voice_title'): return self._m_has_field_voice_title self._m_has_field_voice_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_voice_title', None) @property def has_field_mark_tip_title(self): if hasattr(self, '_m_has_field_mark_tip_title'): return self._m_has_field_mark_tip_title self._m_has_field_mark_tip_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_mark_tip_title', None) @property def has_field_related_dungeon_entry_id(self): if hasattr(self, '_m_has_field_related_dungeon_entry_id'): return self._m_has_field_related_dungeon_entry_id self._m_has_field_related_dungeon_entry_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_related_dungeon_entry_id', None) @property def has_field_related_dungeon_id(self): if hasattr(self, '_m_has_field_related_dungeon_id'): return self._m_has_field_related_dungeon_id self._m_has_field_related_dungeon_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_related_dungeon_id', None) @property def has_field_mark_id(self): if hasattr(self, '_m_has_field_mark_id'): return self._m_has_field_mark_id self._m_has_field_mark_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_mark_id', None) @property def has_field_related_sub_quest_id(self): if hasattr(self, '_m_has_field_related_sub_quest_id'): return self._m_has_field_related_sub_quest_id self._m_has_field_related_sub_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_related_sub_quest_id', None) @property def has_field_exclusive_scene_tags(self): if hasattr(self, '_m_has_field_exclusive_scene_tags'): return self._m_has_field_exclusive_scene_tags self._m_has_field_exclusive_scene_tags = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_exclusive_scene_tags', None) @property def has_field_image_path(self): if hasattr(self, '_m_has_field_image_path'): return self._m_has_field_image_path self._m_has_field_image_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_image_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_voice_desc(self): if hasattr(self, '_m_has_field_voice_desc'): return self._m_has_field_voice_desc self._m_has_field_voice_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_voice_desc', None) @property def has_field_dungeon_passed_lock_tip(self): if hasattr(self, '_m_has_field_dungeon_passed_lock_tip'): return self._m_has_field_dungeon_passed_lock_tip self._m_has_field_dungeon_passed_lock_tip = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_passed_lock_tip', None) @property def has_field_mark_position(self): if hasattr(self, '_m_has_field_mark_position'): return self._m_has_field_mark_position self._m_has_field_mark_position = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_mark_position', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiBirdCirclingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiBirdCirclingData(self._io, self, self._root) class MonsterDefendMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.EntityDefenceMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_type: self.attack_type = Output.EnumAttackType(self._io, self, self._root) if self.has_field_on_defend_succeded: self.on_defend_succeded = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_defend_audio_config: self.defend_audio_config = Output.MonsterDefendAudio(self._io, self, self._root) if self.has_field_random_direction: self.random_direction = self._io.read_u1() if self.has_field_do_not_turn_direction: self.do_not_turn_direction = self._io.read_u1() @property def defend_count_interval(self): if hasattr(self, '_m_defend_count_interval'): return self._m_defend_count_interval self._m_defend_count_interval = self.base.defend_count_interval return getattr(self, '_m_defend_count_interval', None) @property def has_field_defend_audio_config(self): if hasattr(self, '_m_has_field_defend_audio_config'): return self._m_has_field_defend_audio_config self._m_has_field_defend_audio_config = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_defend_audio_config', None) @property def defend_probability_delta(self): if hasattr(self, '_m_defend_probability_delta'): return self._m_defend_probability_delta self._m_defend_probability_delta = self.base.defend_probability_delta return getattr(self, '_m_defend_probability_delta', None) @property def state_i_ds(self): if hasattr(self, '_m_state_i_ds'): return self._m_state_i_ds self._m_state_i_ds = self.base.state_i_ds return getattr(self, '_m_state_i_ds', None) @property def has_field_on_defend_succeded(self): if hasattr(self, '_m_has_field_on_defend_succeded'): return self._m_has_field_on_defend_succeded self._m_has_field_on_defend_succeded = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_defend_succeded', None) @property def has_field_attack_type(self): if hasattr(self, '_m_has_field_attack_type'): return self._m_has_field_attack_type self._m_has_field_attack_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_type', None) @property def has_field_do_not_turn_direction(self): if hasattr(self, '_m_has_field_do_not_turn_direction'): return self._m_has_field_do_not_turn_direction self._m_has_field_do_not_turn_direction = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_do_not_turn_direction', None) @property def defend_trigger_id(self): if hasattr(self, '_m_defend_trigger_id'): return self._m_defend_trigger_id self._m_defend_trigger_id = self.base.defend_trigger_id return getattr(self, '_m_defend_trigger_id', None) @property def defend_probability(self): if hasattr(self, '_m_defend_probability'): return self._m_defend_probability self._m_defend_probability = self.base.defend_probability return getattr(self, '_m_defend_probability', None) @property def always_recover(self): if hasattr(self, '_m_always_recover'): return self._m_always_recover self._m_always_recover = self.base.always_recover return getattr(self, '_m_always_recover', None) @property def has_field_random_direction(self): if hasattr(self, '_m_has_field_random_direction'): return self._m_has_field_random_direction self._m_has_field_random_direction = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_direction', None) @property def can_defence_while_endure_full(self): if hasattr(self, '_m_can_defence_while_endure_full'): return self._m_can_defence_while_endure_full self._m_can_defence_while_endure_full = self.base.can_defence_while_endure_full return getattr(self, '_m_can_defence_while_endure_full', None) @property def defend_angle(self): if hasattr(self, '_m_defend_angle'): return self._m_defend_angle self._m_defend_angle = self.base.defend_angle return getattr(self, '_m_defend_angle', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def defend_time_interval(self): if hasattr(self, '_m_defend_time_interval'): return self._m_defend_time_interval self._m_defend_time_interval = self.base.defend_time_interval return getattr(self, '_m_defend_time_interval', None) class ConfigDirectionByAttackTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_speed_for_predictive: self.speed_for_predictive = self._io.read_f4le() if self.has_field_scatter: self.scatter = Output.DirectionTarDistanceScatter(self._io, self, self._root) @property def has_field_speed_for_predictive(self): if hasattr(self, '_m_has_field_speed_for_predictive'): return self._m_has_field_speed_for_predictive self._m_has_field_speed_for_predictive = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_for_predictive', None) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def has_field_scatter(self): if hasattr(self, '_m_has_field_scatter'): return self._m_has_field_scatter self._m_has_field_scatter = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scatter', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class BoardEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DraftExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispTemplateParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.TemplateParam(self._io, self, self._root) elif _on == 1: self.data = Output.TemplateParamFloat(self._io, self, self._root) elif _on == 3: self.data = Output.TemplateParamString(self._io, self, self._root) elif _on == 2: self.data = Output.TemplateParamInt32(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class GadgetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FetterCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TowerSkipFloorExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBodyLangInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_continue: self.is_continue = self._io.read_u1() if self.has_field_body_lang_param: self.body_lang_param = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_loop_state: self.loop_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_force_interrupt: self.force_interrupt = self._io.read_u1() if self.has_field_random_param_list: self.random_param_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_force_do_free_style: self.force_do_free_style = self._io.read_u1() if self.has_field_can_do_repeat_free_style: self.can_do_repeat_free_style = self._io.read_u1() if self.has_field_dont_clear_pre_free_style: self.dont_clear_pre_free_style = self._io.read_u1() @property def has_field_can_do_repeat_free_style(self): if hasattr(self, '_m_has_field_can_do_repeat_free_style'): return self._m_has_field_can_do_repeat_free_style self._m_has_field_can_do_repeat_free_style = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_can_do_repeat_free_style', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_is_continue(self): if hasattr(self, '_m_has_field_is_continue'): return self._m_has_field_is_continue self._m_has_field_is_continue = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_continue', None) @property def has_field_loop_state(self): if hasattr(self, '_m_has_field_loop_state'): return self._m_has_field_loop_state self._m_has_field_loop_state = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_loop_state', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_dont_clear_pre_free_style(self): if hasattr(self, '_m_has_field_dont_clear_pre_free_style'): return self._m_has_field_dont_clear_pre_free_style self._m_has_field_dont_clear_pre_free_style = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_dont_clear_pre_free_style', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_body_lang_param(self): if hasattr(self, '_m_has_field_body_lang_param'): return self._m_has_field_body_lang_param self._m_has_field_body_lang_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_body_lang_param', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_force_do_free_style(self): if hasattr(self, '_m_has_field_force_do_free_style'): return self._m_has_field_force_do_free_style self._m_has_field_force_do_free_style = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_force_do_free_style', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_force_interrupt(self): if hasattr(self, '_m_has_field_force_interrupt'): return self._m_has_field_force_interrupt self._m_has_field_force_interrupt = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_force_interrupt', None) @property def has_field_random_param_list(self): if hasattr(self, '_m_has_field_random_param_list'): return self._m_has_field_random_param_list self._m_has_field_random_param_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_random_param_list', None) class ActionTokenTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WorldAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerSetPassThrough(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pass_through: self.pass_through = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_pass_through(self): if hasattr(self, '_m_has_field_pass_through'): return self._m_has_field_pass_through self._m_has_field_pass_through = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pass_through', None) class StrengthenBasePointExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialWatcherListDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BySelfForwardAndTargetPosition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_is_xz: self.is_xz = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_xz(self): if hasattr(self, '_m_has_field_is_xz'): return self._m_has_field_is_xz self._m_has_field_is_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_xz', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class FireElementAdditionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_range: self.range = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ratio: self.ratio = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_range', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ratio', None) class TowerFloorExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IntervalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_low: self.low = self._io.read_f4le() if self.has_field_high: self.high = self._io.read_f4le() @property def has_field_low(self): if hasattr(self, '_m_has_field_low'): return self._m_has_field_low self._m_has_field_low = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_low', None) @property def has_field_high(self): if hasattr(self, '_m_has_field_high'): return self._m_has_field_high self._m_has_field_high = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_high', None) class BeingHitMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_attacker: self.to_attacker = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_to_attacker_owner: self.to_attacker_owner = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_to_attacker_origin_owner: self.to_attacker_origin_owner = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_to_attacker(self): if hasattr(self, '_m_has_field_to_attacker'): return self._m_has_field_to_attacker self._m_has_field_to_attacker = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_attacker', None) @property def has_field_to_attacker_owner(self): if hasattr(self, '_m_has_field_to_attacker_owner'): return self._m_has_field_to_attacker_owner self._m_has_field_to_attacker_owner = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_attacker_owner', None) @property def has_field_to_attacker_origin_owner(self): if hasattr(self, '_m_has_field_to_attacker_origin_owner'): return self._m_has_field_to_attacker_origin_owner self._m_has_field_to_attacker_origin_owner = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_to_attacker_origin_owner', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicInt32lessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigEquipment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attach_to: self.attach_to = AuxTypes.String(self._io, self, self._root) if self.has_field_sub_gadget_id: self.sub_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_attach_to: self.sub_attach_to = AuxTypes.String(self._io, self, self._root) if self.has_field_aux_to_trans: self.aux_to_trans = AuxTypes.String(self._io, self, self._root) if self.has_field_equip_entity_type: self.equip_entity_type = Output.EnumEquipEntityType(self._io, self, self._root) if self.has_field_blade_fx: self.blade_fx = Output.ConfigBladeElementFx(self._io, self, self._root) if self.has_field_bow_data: self.bow_data = Output.ConfigBowData(self._io, self, self._root) @property def has_field_attach_to(self): if hasattr(self, '_m_has_field_attach_to'): return self._m_has_field_attach_to self._m_has_field_attach_to = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_to', None) @property def has_field_blade_fx(self): if hasattr(self, '_m_has_field_blade_fx'): return self._m_has_field_blade_fx self._m_has_field_blade_fx = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_blade_fx', None) @property def has_field_sub_gadget_id(self): if hasattr(self, '_m_has_field_sub_gadget_id'): return self._m_has_field_sub_gadget_id self._m_has_field_sub_gadget_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sub_gadget_id', None) @property def has_field_aux_to_trans(self): if hasattr(self, '_m_has_field_aux_to_trans'): return self._m_has_field_aux_to_trans self._m_has_field_aux_to_trans = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_aux_to_trans', None) @property def has_field_equip_entity_type(self): if hasattr(self, '_m_has_field_equip_entity_type'): return self._m_has_field_equip_entity_type self._m_has_field_equip_entity_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_equip_entity_type', None) @property def has_field_bow_data(self): if hasattr(self, '_m_has_field_bow_data'): return self._m_has_field_bow_data self._m_has_field_bow_data = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_bow_data', None) @property def has_field_sub_attach_to(self): if hasattr(self, '_m_has_field_sub_attach_to'): return self._m_has_field_sub_attach_to self._m_has_field_sub_attach_to = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sub_attach_to', None) class ConfigMusicParameterizedStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicStimulusHandler(self._io, self, self._root) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class CoopRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUVector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.Vector(self._io, self, self._root) class ChannellerSlabChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest: self.pre_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_pre_quest(self): if hasattr(self, '_m_has_field_pre_quest'): return self._m_has_field_pre_quest self._m_has_field_pre_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pre_quest', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) class EnumInteractActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InteractActionType, self.data.value) return getattr(self, '_m_value', None) class AttachElementTypeResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_duration_ratio: self.duration_ratio = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration_ratio(self): if hasattr(self, '_m_has_field_duration_ratio'): return self._m_has_field_duration_ratio self._m_has_field_duration_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) class ExploreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_exp', None) class SetRegionalPlayVarValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_var_type: self.var_type = Output.EnumRegionalPlayVarType(self._io, self, self._root) if self.has_field_var_value: self.var_value = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_var_type(self): if hasattr(self, '_m_has_field_var_type'): return self._m_has_field_var_type self._m_has_field_var_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_var_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_var_value(self): if hasattr(self, '_m_has_field_var_value'): return self._m_has_field_var_value self._m_has_field_var_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_var_value', None) class WinterCampSnowmanExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id_list: self.item_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_id_list: self.group_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_bundle_id: self.group_bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_item_id_list(self): if hasattr(self, '_m_has_field_item_id_list'): return self._m_has_field_item_id_list self._m_has_field_item_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_id_list', None) @property def has_field_group_id_list(self): if hasattr(self, '_m_has_field_group_id_list'): return self._m_has_field_group_id_list self._m_has_field_group_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id_list', None) @property def has_field_group_bundle_id(self): if hasattr(self, '_m_has_field_group_bundle_id'): return self._m_has_field_group_bundle_id self._m_has_field_group_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_bundle_id', None) class DragonSpineMissionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfDragonSpineMissionFinishConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_finish_exec', None) class ConfigRuleLimitFrameGlobal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_limit_frame: self.limit_frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_limit_frame(self): if hasattr(self, '_m_has_field_limit_frame'): return self._m_has_field_limit_frame self._m_has_field_limit_frame = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_limit_frame', None) class ConfigCodexQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_type: self.quest_type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_main_quest_title: self.main_quest_title = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_main_quest_desp: self.main_quest_desp = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_chapter_title: self.chapter_title = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_chapter_num: self.chapter_num = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_sub_quests: self.sub_quests = Output.ArrayOfConfigCodexQuestSubQuestLengthU(self._io, self, self._root) @property def has_field_main_quest_desp(self): if hasattr(self, '_m_has_field_main_quest_desp'): return self._m_has_field_main_quest_desp self._m_has_field_main_quest_desp = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_main_quest_desp', None) @property def has_field_chapter_num(self): if hasattr(self, '_m_has_field_chapter_num'): return self._m_has_field_chapter_num self._m_has_field_chapter_num = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_chapter_num', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_main_quest_title(self): if hasattr(self, '_m_has_field_main_quest_title'): return self._m_has_field_main_quest_title self._m_has_field_main_quest_title = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_main_quest_title', None) @property def has_field_quest_type(self): if hasattr(self, '_m_has_field_quest_type'): return self._m_has_field_quest_type self._m_has_field_quest_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_type', None) @property def has_field_chapter_title(self): if hasattr(self, '_m_has_field_chapter_title'): return self._m_has_field_chapter_title self._m_has_field_chapter_title = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_chapter_title', None) @property def has_field_sub_quests(self): if hasattr(self, '_m_has_field_sub_quests'): return self._m_has_field_sub_quests self._m_has_field_sub_quests = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_sub_quests', None) class AudioDialogReaction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_ops_on_start: self.state_ops_on_start = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) if self.has_field_state_ops_on_finish: self.state_ops_on_finish = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) if self.has_field_event_on_start: self.event_on_start = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_event_on_finish: self.event_on_finish = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_event_on_start(self): if hasattr(self, '_m_has_field_event_on_start'): return self._m_has_field_event_on_start self._m_has_field_event_on_start = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_event_on_start', None) @property def has_field_state_ops_on_start(self): if hasattr(self, '_m_has_field_state_ops_on_start'): return self._m_has_field_state_ops_on_start self._m_has_field_state_ops_on_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_ops_on_start', None) @property def has_field_state_ops_on_finish(self): if hasattr(self, '_m_has_field_state_ops_on_finish'): return self._m_has_field_state_ops_on_finish self._m_has_field_state_ops_on_finish = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_state_ops_on_finish', None) @property def has_field_event_on_finish(self): if hasattr(self, '_m_has_field_event_on_finish'): return self._m_has_field_event_on_finish self._m_has_field_event_on_finish = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_event_on_finish', None) class DictOfAuxTypesStringConfigSoundBankUnloadPolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigSoundBankUnloadPolicy(self._io, self, self._root)) class EnumSignInCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SignInCondType, self.data.value) return getattr(self, '_m_value', None) class OfferingOpenStateConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldLimitShopCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestContentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SceneExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumSceneType(self._io, self, self._root) if self.has_field_subtype: self.subtype = Output.EnumSceneSubType(self._io, self, self._root) if self.has_field_ignore_nav_mesh: self.ignore_nav_mesh = self._io.read_u1() if self.has_field_navmesh_mode: self.navmesh_mode = Output.EnumNavmeshModeType(self._io, self, self._root) if self.has_field_script_data: self.script_data = AuxTypes.String(self._io, self, self._root) if self.has_field_override_default_profile: self.override_default_profile = AuxTypes.String(self._io, self, self._root) if self.has_field_level_entity_config: self.level_entity_config = AuxTypes.String(self._io, self, self._root) if self.has_field_entity_appear_sorted: self.entity_appear_sorted = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_specified_avatar_list: self.specified_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_specified_avatar_num: self.max_specified_avatar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_fix_time: self.scene_fix_time = self._io.read_f4le() if self.has_field_comment: self.comment = AuxTypes.String(self._io, self, self._root) if self.has_field_safe_point: self.safe_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_type: self.mp_type = Output.EnumSceneMpType(self._io, self, self._root) if self.has_field_is_allow_map_mark_point: self.is_allow_map_mark_point = self._io.read_u1() if self.has_field_is_delete_map_mark_point: self.is_delete_map_mark_point = self._io.read_u1() if self.has_field_dungeon_entry_point: self.dungeon_entry_point = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_ignore_nav_mesh(self): if hasattr(self, '_m_has_field_ignore_nav_mesh'): return self._m_has_field_ignore_nav_mesh self._m_has_field_ignore_nav_mesh = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ignore_nav_mesh', None) @property def has_field_level_entity_config(self): if hasattr(self, '_m_has_field_level_entity_config'): return self._m_has_field_level_entity_config self._m_has_field_level_entity_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_level_entity_config', None) @property def has_field_specified_avatar_list(self): if hasattr(self, '_m_has_field_specified_avatar_list'): return self._m_has_field_specified_avatar_list self._m_has_field_specified_avatar_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_specified_avatar_list', None) @property def has_field_is_delete_map_mark_point(self): if hasattr(self, '_m_has_field_is_delete_map_mark_point'): return self._m_has_field_is_delete_map_mark_point self._m_has_field_is_delete_map_mark_point = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_is_delete_map_mark_point', None) @property def has_field_comment(self): if hasattr(self, '_m_has_field_comment'): return self._m_has_field_comment self._m_has_field_comment = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_comment', None) @property def has_field_is_allow_map_mark_point(self): if hasattr(self, '_m_has_field_is_allow_map_mark_point'): return self._m_has_field_is_allow_map_mark_point self._m_has_field_is_allow_map_mark_point = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_allow_map_mark_point', None) @property def has_field_scene_fix_time(self): if hasattr(self, '_m_has_field_scene_fix_time'): return self._m_has_field_scene_fix_time self._m_has_field_scene_fix_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_scene_fix_time', None) @property def has_field_mp_type(self): if hasattr(self, '_m_has_field_mp_type'): return self._m_has_field_mp_type self._m_has_field_mp_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_mp_type', None) @property def has_field_safe_point(self): if hasattr(self, '_m_has_field_safe_point'): return self._m_has_field_safe_point self._m_has_field_safe_point = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_safe_point', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_navmesh_mode(self): if hasattr(self, '_m_has_field_navmesh_mode'): return self._m_has_field_navmesh_mode self._m_has_field_navmesh_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_navmesh_mode', None) @property def has_field_entity_appear_sorted(self): if hasattr(self, '_m_has_field_entity_appear_sorted'): return self._m_has_field_entity_appear_sorted self._m_has_field_entity_appear_sorted = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_entity_appear_sorted', None) @property def has_field_subtype(self): if hasattr(self, '_m_has_field_subtype'): return self._m_has_field_subtype self._m_has_field_subtype = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_subtype', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_script_data(self): if hasattr(self, '_m_has_field_script_data'): return self._m_has_field_script_data self._m_has_field_script_data = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_script_data', None) @property def has_field_dungeon_entry_point(self): if hasattr(self, '_m_has_field_dungeon_entry_point'): return self._m_has_field_dungeon_entry_point self._m_has_field_dungeon_entry_point = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_entry_point', None) @property def has_field_max_specified_avatar_num(self): if hasattr(self, '_m_has_field_max_specified_avatar_num'): return self._m_has_field_max_specified_avatar_num self._m_has_field_max_specified_avatar_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_max_specified_avatar_num', None) @property def has_field_override_default_profile(self): if hasattr(self, '_m_has_field_override_default_profile'): return self._m_has_field_override_default_profile self._m_has_field_override_default_profile = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_override_default_profile', None) class ExploreAreaTotalExpExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_exp: self.total_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reputation_ratio: self.reputation_ratio = self._io.read_f4le() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_total_exp(self): if hasattr(self, '_m_has_field_total_exp'): return self._m_has_field_total_exp self._m_has_field_total_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_total_exp', None) @property def has_field_reputation_ratio(self): if hasattr(self, '_m_has_field_reputation_ratio'): return self._m_has_field_reputation_ratio self._m_has_field_reputation_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reputation_ratio', None) class IrodoriChessCardTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGraphicsSettingEntryType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GraphicsSettingEntryType, self.data.value) return getattr(self, '_m_value', None) class TileAttackManagerMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_id: self.attack_id = AuxTypes.String(self._io, self, self._root) if self.has_field_interval: self.interval = self._io.read_f4le() if self.has_field_camp_type: self.camp_type = Output.EnumTileCampType(self._io, self, self._root) if self.has_field_fix_camp: self.fix_camp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_authority_handle: self.authority_handle = self._io.read_u1() if self.has_field_attack_info: self.attack_info = Output.ConfigAttackInfo(self._io, self, self._root) @property def has_field_attack_info(self): if hasattr(self, '_m_has_field_attack_info'): return self._m_has_field_attack_info self._m_has_field_attack_info = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_attack_info', None) @property def has_field_interval(self): if hasattr(self, '_m_has_field_interval'): return self._m_has_field_interval self._m_has_field_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_interval', None) @property def has_field_camp_type(self): if hasattr(self, '_m_has_field_camp_type'): return self._m_has_field_camp_type self._m_has_field_camp_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camp_type', None) @property def has_field_fix_camp(self): if hasattr(self, '_m_has_field_fix_camp'): return self._m_has_field_fix_camp self._m_has_field_fix_camp = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fix_camp', None) @property def has_field_attack_id(self): if hasattr(self, '_m_has_field_attack_id'): return self._m_has_field_attack_id self._m_has_field_attack_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_id', None) @property def has_field_authority_handle(self): if hasattr(self, '_m_has_field_authority_handle'): return self._m_has_field_authority_handle self._m_has_field_authority_handle = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_authority_handle', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigBladeElementFx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_slash: self.slash = AuxTypes.String(self._io, self, self._root) if self.has_field_color_a: self.color_a = AuxTypes.String(self._io, self, self._root) if self.has_field_color_b: self.color_b = AuxTypes.String(self._io, self, self._root) @property def has_field_slash(self): if hasattr(self, '_m_has_field_slash'): return self._m_has_field_slash self._m_has_field_slash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_slash', None) @property def has_field_color_a(self): if hasattr(self, '_m_has_field_color_a'): return self._m_has_field_color_a self._m_has_field_color_a = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_color_a', None) @property def has_field_color_b(self): if hasattr(self, '_m_has_field_color_b'): return self._m_has_field_color_b self._m_has_field_color_b = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_color_b', None) class ActivityGachaRobotExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SelectTargets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_top_limit: self.top_limit = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_entity_type_priority: self.entity_type_priority = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_sort_type: self.sort_type = Output.EnumSelectTargetsSortType(self._io, self, self._root) @property def has_field_top_limit(self): if hasattr(self, '_m_has_field_top_limit'): return self._m_has_field_top_limit self._m_has_field_top_limit = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_top_limit', None) @property def has_field_entity_type_priority(self): if hasattr(self, '_m_has_field_entity_type_priority'): return self._m_has_field_entity_type_priority self._m_has_field_entity_type_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_entity_type_priority', None) @property def has_field_sort_type(self): if hasattr(self, '_m_has_field_sort_type'): return self._m_has_field_sort_type self._m_has_field_sort_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sort_type', None) class EnumWidgetSkillReplaceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetSkillReplaceType, self.data.value) return getattr(self, '_m_value', None) class EnumChessCardNumericalModificationMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardNumericalModificationMode, self.data.value) return getattr(self, '_m_value', None) class RoutineTypeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_routine_type: self.routine_type = Output.EnumGeneralRoutineType(self._io, self, self._root) if self.has_field_refresh_num: self.refresh_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_limit_num: self.reward_limit_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_id: self.refresh_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delay_unload_time: self.delay_unload_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_delay_unload_time(self): if hasattr(self, '_m_has_field_delay_unload_time'): return self._m_has_field_delay_unload_time self._m_has_field_delay_unload_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_delay_unload_time', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_reward_limit_num(self): if hasattr(self, '_m_has_field_reward_limit_num'): return self._m_has_field_reward_limit_num self._m_has_field_reward_limit_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_limit_num', None) @property def has_field_refresh_num(self): if hasattr(self, '_m_has_field_refresh_num'): return self._m_has_field_refresh_num self._m_has_field_refresh_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_refresh_num', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_refresh_id(self): if hasattr(self, '_m_has_field_refresh_id'): return self._m_has_field_refresh_id self._m_has_field_refresh_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_refresh_id', None) @property def has_field_routine_type(self): if hasattr(self, '_m_has_field_routine_type'): return self._m_has_field_routine_type self._m_has_field_routine_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_routine_type', None) class EnumRegionSearchRecycleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionSearchRecycleType, self.data.value) return getattr(self, '_m_value', None) class GadgetStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideDungeonIdCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id_list: self.dungeon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_dungeon: self.is_dungeon = self._io.read_u1() @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_is_dungeon(self): if hasattr(self, '_m_has_field_is_dungeon'): return self._m_has_field_is_dungeon self._m_has_field_is_dungeon = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_dungeon', None) @property def has_field_dungeon_id_list(self): if hasattr(self, '_m_has_field_dungeon_id_list'): return self._m_has_field_dungeon_id_list self._m_has_field_dungeon_id_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dungeon_id_list', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dungeon_id', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class MechanicusCardEffectExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumMechanicusCardTargetType(self._io, self, self._root) if self.has_field_target_param_list: self.target_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumMechanicusCardEffectType(self._io, self, self._root) if self.has_field_effect_str_param: self.effect_str_param = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_param1: self.effect_param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param2: self.effect_param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param3: self.effect_param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_effect_str_param(self): if hasattr(self, '_m_has_field_effect_str_param'): return self._m_has_field_effect_str_param self._m_has_field_effect_str_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effect_str_param', None) @property def has_field_effect_param3(self): if hasattr(self, '_m_has_field_effect_param3'): return self._m_has_field_effect_param3 self._m_has_field_effect_param3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_effect_param3', None) @property def has_field_effect_param1(self): if hasattr(self, '_m_has_field_effect_param1'): return self._m_has_field_effect_param1 self._m_has_field_effect_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_param1', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_target_param_list(self): if hasattr(self, '_m_has_field_target_param_list'): return self._m_has_field_target_param_list self._m_has_field_target_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_target_param_list', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_target_type', None) @property def has_field_effect_param2(self): if hasattr(self, '_m_has_field_effect_param2'): return self._m_has_field_effect_param2 self._m_has_field_effect_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_effect_param2', None) class CenterPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopTemperamentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DragonSpineEnhanceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_ability_group_id: self.activity_ability_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_process: self.process = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_ability_group_id(self): if hasattr(self, '_m_has_field_activity_ability_group_id'): return self._m_has_field_activity_ability_group_id self._m_has_field_activity_ability_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_ability_group_id', None) @property def has_field_process(self): if hasattr(self, '_m_has_field_process'): return self._m_has_field_process self._m_has_field_process = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_process', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) class DictOfAuxTypesStringConfigAiSensingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAiSensingSetting(self._io, self, self._root)) class EnumOpActivityBonusType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpActivityBonusType, self.data.value) return getattr(self, '_m_value', None) class PlatformRotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestGuideAutoComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumServerBuffType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ServerBuffType, self.data.value) return getattr(self, '_m_value', None) class AttachModifierToTargetDistanceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_i_ds: self.target_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_byserver: self.byserver = self._io.read_u1() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_remove_applied_modifier: self.remove_applied_modifier = self._io.read_u1() if self.has_field_blend_param: self.blend_param = AuxTypes.String(self._io, self, self._root) if self.has_field_blend_distance: self.blend_distance = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_target_i_ds(self): if hasattr(self, '_m_has_field_target_i_ds'): return self._m_has_field_target_i_ds self._m_has_field_target_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_i_ds', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_blend_distance(self): if hasattr(self, '_m_has_field_blend_distance'): return self._m_has_field_blend_distance self._m_has_field_blend_distance = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_blend_distance', None) @property def has_field_byserver(self): if hasattr(self, '_m_has_field_byserver'): return self._m_has_field_byserver self._m_has_field_byserver = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_byserver', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_blend_param(self): if hasattr(self, '_m_has_field_blend_param'): return self._m_has_field_blend_param self._m_has_field_blend_param = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_blend_param', None) @property def has_field_remove_applied_modifier(self): if hasattr(self, '_m_has_field_remove_applied_modifier'): return self._m_has_field_remove_applied_modifier self._m_has_field_remove_applied_modifier = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_remove_applied_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class ConfigClimateUi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_climate_info_btn_icon: self.climate_info_btn_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_climate_dialog_title: self.climate_dialog_title = AuxTypes.String(self._io, self, self._root) if self.has_field_climate_dialog_desc: self.climate_dialog_desc = AuxTypes.String(self._io, self, self._root) if self.has_field_climate_dialog_left_icon: self.climate_dialog_left_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_climate_dialog_left_bg: self.climate_dialog_left_bg = AuxTypes.String(self._io, self, self._root) if self.has_field_show_climate_meter: self.show_climate_meter = self._io.read_u1() if self.has_field_climate_meter_color_index: self.climate_meter_color_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_climate_meter_bg_color_index: self.climate_meter_bg_color_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_screen_effect_index: self.screen_effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_climate_info_show_with_meter_type: self.climate_info_show_with_meter_type = self._io.read_u1() if self.has_field_ui_low_warning_ratio: self.ui_low_warning_ratio = self._io.read_f4le() if self.has_field_ui_len_low_intensity: self.ui_len_low_intensity = self._io.read_f4le() if self.has_field_ui_middle_warning_ratio: self.ui_middle_warning_ratio = self._io.read_f4le() if self.has_field_ui_len_middle_intensity: self.ui_len_middle_intensity = self._io.read_f4le() @property def has_field_climate_meter_color_index(self): if hasattr(self, '_m_has_field_climate_meter_color_index'): return self._m_has_field_climate_meter_color_index self._m_has_field_climate_meter_color_index = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_climate_meter_color_index', None) @property def has_field_climate_dialog_desc(self): if hasattr(self, '_m_has_field_climate_dialog_desc'): return self._m_has_field_climate_dialog_desc self._m_has_field_climate_dialog_desc = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_climate_dialog_desc', None) @property def has_field_climate_info_btn_icon(self): if hasattr(self, '_m_has_field_climate_info_btn_icon'): return self._m_has_field_climate_info_btn_icon self._m_has_field_climate_info_btn_icon = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_climate_info_btn_icon', None) @property def has_field_ui_len_low_intensity(self): if hasattr(self, '_m_has_field_ui_len_low_intensity'): return self._m_has_field_ui_len_low_intensity self._m_has_field_ui_len_low_intensity = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_ui_len_low_intensity', None) @property def has_field_climate_info_show_with_meter_type(self): if hasattr(self, '_m_has_field_climate_info_show_with_meter_type'): return self._m_has_field_climate_info_show_with_meter_type self._m_has_field_climate_info_show_with_meter_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_climate_info_show_with_meter_type', None) @property def has_field_climate_dialog_title(self): if hasattr(self, '_m_has_field_climate_dialog_title'): return self._m_has_field_climate_dialog_title self._m_has_field_climate_dialog_title = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_climate_dialog_title', None) @property def has_field_climate_meter_bg_color_index(self): if hasattr(self, '_m_has_field_climate_meter_bg_color_index'): return self._m_has_field_climate_meter_bg_color_index self._m_has_field_climate_meter_bg_color_index = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_climate_meter_bg_color_index', None) @property def has_field_climate_dialog_left_icon(self): if hasattr(self, '_m_has_field_climate_dialog_left_icon'): return self._m_has_field_climate_dialog_left_icon self._m_has_field_climate_dialog_left_icon = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_climate_dialog_left_icon', None) @property def has_field_ui_low_warning_ratio(self): if hasattr(self, '_m_has_field_ui_low_warning_ratio'): return self._m_has_field_ui_low_warning_ratio self._m_has_field_ui_low_warning_ratio = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_ui_low_warning_ratio', None) @property def has_field_climate_dialog_left_bg(self): if hasattr(self, '_m_has_field_climate_dialog_left_bg'): return self._m_has_field_climate_dialog_left_bg self._m_has_field_climate_dialog_left_bg = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_climate_dialog_left_bg', None) @property def has_field_ui_middle_warning_ratio(self): if hasattr(self, '_m_has_field_ui_middle_warning_ratio'): return self._m_has_field_ui_middle_warning_ratio self._m_has_field_ui_middle_warning_ratio = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_ui_middle_warning_ratio', None) @property def has_field_show_climate_meter(self): if hasattr(self, '_m_has_field_show_climate_meter'): return self._m_has_field_show_climate_meter self._m_has_field_show_climate_meter = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_climate_meter', None) @property def has_field_ui_len_middle_intensity(self): if hasattr(self, '_m_has_field_ui_len_middle_intensity'): return self._m_has_field_ui_len_middle_intensity self._m_has_field_ui_len_middle_intensity = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_ui_len_middle_intensity', None) @property def has_field_screen_effect_index(self): if hasattr(self, '_m_has_field_screen_effect_index'): return self._m_has_field_screen_effect_index self._m_has_field_screen_effect_index = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_screen_effect_index', None) class ArrayOfConfigHomeworldFurnitureLightDetailLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldFurnitureLightDetail(self._io, self, self._root)) class ConfigAiSensing(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_settings: self.settings = Output.DictOfAuxTypesStringConfigAiSensingSetting(self._io, self, self._root) if self.has_field_templates: self.templates = Output.DictOfAuxTypesStringDictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_settings(self): if hasattr(self, '_m_has_field_settings'): return self._m_has_field_settings self._m_has_field_settings = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_settings', None) @property def has_field_templates(self): if hasattr(self, '_m_has_field_templates'): return self._m_has_field_templates self._m_has_field_templates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_templates', None) class HitLevelTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_level: self.hit_level = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_impulse_x: self.hit_impulse_x = self._io.read_f4le() if self.has_field_hit_impulse_y: self.hit_impulse_y = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_hit_level(self): if hasattr(self, '_m_has_field_hit_level'): return self._m_has_field_hit_level self._m_has_field_hit_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hit_level', None) @property def has_field_hit_impulse_x(self): if hasattr(self, '_m_has_field_hit_impulse_x'): return self._m_has_field_hit_impulse_x self._m_has_field_hit_impulse_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_hit_impulse_x', None) @property def has_field_hit_impulse_y(self): if hasattr(self, '_m_has_field_hit_impulse_y'): return self._m_has_field_hit_impulse_y self._m_has_field_hit_impulse_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hit_impulse_y', None) class MonitorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) class ArrayOfShakeByAinmatorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ShakeByAinmator(self._io, self, self._root)) class ActivitySteepleChaseConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DialogVoiceSegmentData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigAbilityPredicateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigAbilityPredicate(self._io, self, self._root)) class AvatarLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUCoopSavePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUCoopSavePoint(self._io, self, self._root)) class CustomLevelGroupConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideSceneIdCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id_list: self.scene_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_scene: self.is_scene = self._io.read_u1() @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_is_scene(self): if hasattr(self, '_m_has_field_is_scene'): return self._m_has_field_is_scene self._m_has_field_is_scene = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_scene', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_scene_id_list(self): if hasattr(self, '_m_has_field_scene_id_list'): return self._m_has_field_scene_id_list self._m_has_field_scene_id_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scene_id_list', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class BonusActivityClientExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterDrop(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hp_percent: self.hp_percent = self._io.read_f4le() @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_hp_percent(self): if hasattr(self, '_m_has_field_hp_percent'): return self._m_has_field_hp_percent self._m_has_field_hp_percent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hp_percent', None) class DispConfigScenePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.VirtualTransPoint(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigForceField(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigLocalTrigger(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigScenePoint(self._io, self, self._root) elif _on == 4: self.data = Output.DungeonQuitPoint(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigCannonField(self._io, self, self._root) elif _on == 6: self.data = Output.PersonalSceneJumpPoint(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigSpeedupField(self._io, self, self._root) elif _on == 7: self.data = Output.SceneBuildingPoint(self._io, self, self._root) elif _on == 1: self.data = Output.SceneTransPoint(self._io, self, self._root) elif _on == 13: self.data = Output.DungeonEntry(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigLocalEntity(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigLoadingDoor(self._io, self, self._root) elif _on == 3: self.data = Output.DungeonWayPoint(self._io, self, self._root) elif _on == 5: self.data = Output.DungeonRewardPoint(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigAirflowField(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigFireGrassAirflowField(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigConstForceField(self._io, self, self._root) elif _on == 8: self.data = Output.DungeonSlipRevivePoint(self._io, self, self._root) elif _on == 9: self.data = Output.SceneVehicleSummonPoint(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigDirectedForceField(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigRiseField(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigWindmill(self._io, self, self._root) elif _on == 2: self.data = Output.DungeonExit(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigLightCore(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigDirectedForceField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigConstForceField(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class WeaponCurveExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_curve_infos: self.curve_infos = Output.ArrayOfGrowCurveInfoLengthS(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_curve_infos(self): if hasattr(self, '_m_has_field_curve_infos'): return self._m_has_field_curve_infos self._m_has_field_curve_infos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_curve_infos', None) class EnumCrystalLinkDifficultyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CrystalLinkDifficultyType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfRandomQuestContentLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandomQuestContent(self._io, self, self._root)) class DoActionByStateIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_enter_predicates: self.enter_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_exit_predicates: self.exit_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_enter_actions: self.enter_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_exit_actions: self.exit_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_enter_actions(self): if hasattr(self, '_m_has_field_enter_actions'): return self._m_has_field_enter_actions self._m_has_field_enter_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enter_actions', None) @property def has_field_exit_predicates(self): if hasattr(self, '_m_has_field_exit_predicates'): return self._m_has_field_exit_predicates self._m_has_field_exit_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_exit_predicates', None) @property def has_field_exit_actions(self): if hasattr(self, '_m_has_field_exit_actions'): return self._m_has_field_exit_actions self._m_has_field_exit_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_exit_actions', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_enter_predicates(self): if hasattr(self, '_m_has_field_enter_predicates'): return self._m_has_field_enter_predicates self._m_has_field_enter_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enter_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumSettleUiType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SettleUiType, self.data.value) return getattr(self, '_m_value', None) class ByteArrayEncode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeBattleSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_name: self.skill_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_desc: self.skill_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_args: self.desc_args = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_num: self.material_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_global_value_name: self.server_global_value_name = AuxTypes.String(self._io, self, self._root) @property def has_field_skill_desc(self): if hasattr(self, '_m_has_field_skill_desc'): return self._m_has_field_skill_desc self._m_has_field_skill_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_skill_desc', None) @property def has_field_skill_name(self): if hasattr(self, '_m_has_field_skill_name'): return self._m_has_field_skill_name self._m_has_field_skill_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_skill_name', None) @property def has_field_material_num(self): if hasattr(self, '_m_has_field_material_num'): return self._m_has_field_material_num self._m_has_field_material_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_material_num', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_skill_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_server_global_value_name(self): if hasattr(self, '_m_has_field_server_global_value_name'): return self._m_has_field_server_global_value_name self._m_has_field_server_global_value_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_server_global_value_name', None) @property def has_field_desc_args(self): if hasattr(self, '_m_has_field_desc_args'): return self._m_has_field_desc_args self._m_has_field_desc_args = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc_args', None) class DropRandomTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SteerAttackTraceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SteerAttackMixin(self._io, self, self._root) @property def start_normalized_time(self): if hasattr(self, '_m_start_normalized_time'): return self._m_start_normalized_time self._m_start_normalized_time = self.base.start_normalized_time return getattr(self, '_m_start_normalized_time', None) @property def steer_state_i_ds(self): if hasattr(self, '_m_steer_state_i_ds'): return self._m_steer_state_i_ds self._m_steer_state_i_ds = self.base.steer_state_i_ds return getattr(self, '_m_steer_state_i_ds', None) @property def attack_distance(self): if hasattr(self, '_m_attack_distance'): return self._m_attack_distance self._m_attack_distance = self.base.attack_distance return getattr(self, '_m_attack_distance', None) @property def attack_trigger(self): if hasattr(self, '_m_attack_trigger'): return self._m_attack_trigger self._m_attack_trigger = self.base.attack_trigger return getattr(self, '_m_attack_trigger', None) @property def attack_angle(self): if hasattr(self, '_m_attack_angle'): return self._m_attack_angle self._m_attack_angle = self.base.attack_angle return getattr(self, '_m_attack_angle', None) @property def end_normalized_time(self): if hasattr(self, '_m_end_normalized_time'): return self._m_end_normalized_time self._m_end_normalized_time = self.base.end_normalized_time return getattr(self, '_m_end_normalized_time', None) @property def remote_steer_to_local_target(self): if hasattr(self, '_m_remote_steer_to_local_target'): return self._m_remote_steer_to_local_target self._m_remote_steer_to_local_target = self.base.remote_steer_to_local_target return getattr(self, '_m_remote_steer_to_local_target', None) @property def facing_target_types(self): if hasattr(self, '_m_facing_target_types'): return self._m_facing_target_types self._m_facing_target_types = self.base.facing_target_types return getattr(self, '_m_facing_target_types', None) @property def angular_speed(self): if hasattr(self, '_m_angular_speed'): return self._m_angular_speed self._m_angular_speed = self.base.angular_speed return getattr(self, '_m_angular_speed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigJob(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_force_main_thread: self.is_force_main_thread = self._io.read_u1() if self.has_field_schedule_job_type: self.schedule_job_type = Output.EnumConfigScheduleJobType(self._io, self, self._root) if self.has_field_schedule_type: self.schedule_type = Output.EnumConfigSchedulerType(self._io, self, self._root) if self.has_field_max_node_num: self.max_node_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_schedule_job_type(self): if hasattr(self, '_m_has_field_schedule_job_type'): return self._m_has_field_schedule_job_type self._m_has_field_schedule_job_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_schedule_job_type', None) @property def has_field_max_node_num(self): if hasattr(self, '_m_has_field_max_node_num'): return self._m_has_field_max_node_num self._m_has_field_max_node_num = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_node_num', None) @property def has_field_is_force_main_thread(self): if hasattr(self, '_m_has_field_is_force_main_thread'): return self._m_has_field_is_force_main_thread self._m_has_field_is_force_main_thread = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_force_main_thread', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_schedule_type(self): if hasattr(self, '_m_has_field_schedule_type'): return self._m_has_field_schedule_type self._m_has_field_schedule_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_schedule_type', None) class WidgetSkillReplaceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LoadingSituationExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiPoseControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_items: self.items = Output.ArrayOfConfigAiPoseControlItemLengthU(self._io, self, self._root) @property def has_field_items(self): if hasattr(self, '_m_has_field_items'): return self._m_has_field_items self._m_has_field_items = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_items', None) class ElementReactionSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfTowerBuffLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.TowerBuff(self._io, self, self._root)) class EnumItemLimitType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemLimitType, self.data.value) return getattr(self, '_m_value', None) class ConfigMusicUInt32listAbsenceCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listMemberCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class BlossomReviseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TrialAvatarFetterDataConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CombineUnlockMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiFleeOnBlockAvatarLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFleeOnBlockAvatarLandingData(self._io, self, self._root)) class ReputationCityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explore_area_vec: self.explore_area_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_virtual_item_id: self.virtual_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_state: self.open_state = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_bg_icon_path: self.bg_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_bg_effect_path: self.bg_effect_path = AuxTypes.String(self._io, self, self._root) if self.has_field_explain_title: self.explain_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_item_id: self.reward_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_item_desc: self.reward_item_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_item_icon: self.reward_item_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_reward_bg_icon: self.reward_bg_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_city_icon: self.city_icon = AuxTypes.String(self._io, self, self._root) @property def has_field_bg_effect_path(self): if hasattr(self, '_m_has_field_bg_effect_path'): return self._m_has_field_bg_effect_path self._m_has_field_bg_effect_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_bg_effect_path', None) @property def has_field_bg_icon_path(self): if hasattr(self, '_m_has_field_bg_icon_path'): return self._m_has_field_bg_icon_path self._m_has_field_bg_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_bg_icon_path', None) @property def has_field_reward_item_icon(self): if hasattr(self, '_m_has_field_reward_item_icon'): return self._m_has_field_reward_item_icon self._m_has_field_reward_item_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_reward_item_icon', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_city_icon(self): if hasattr(self, '_m_has_field_city_icon'): return self._m_has_field_city_icon self._m_has_field_city_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_city_icon', None) @property def has_field_virtual_item_id(self): if hasattr(self, '_m_has_field_virtual_item_id'): return self._m_has_field_virtual_item_id self._m_has_field_virtual_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_virtual_item_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_state', None) @property def has_field_reward_bg_icon(self): if hasattr(self, '_m_has_field_reward_bg_icon'): return self._m_has_field_reward_bg_icon self._m_has_field_reward_bg_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_reward_bg_icon', None) @property def has_field_reward_item_desc(self): if hasattr(self, '_m_has_field_reward_item_desc'): return self._m_has_field_reward_item_desc self._m_has_field_reward_item_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reward_item_desc', None) @property def has_field_reward_item_id(self): if hasattr(self, '_m_has_field_reward_item_id'): return self._m_has_field_reward_item_id self._m_has_field_reward_item_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_item_id', None) @property def has_field_explain_title(self): if hasattr(self, '_m_has_field_explain_title'): return self._m_has_field_explain_title self._m_has_field_explain_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_explain_title', None) @property def has_field_explore_area_vec(self): if hasattr(self, '_m_has_field_explore_area_vec'): return self._m_has_field_explore_area_vec self._m_has_field_explore_area_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_explore_area_vec', None) class BlossomOpenExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireworksExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MatchNewRuleSpecifiedExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByAttackTags(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tags', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DropElemControlTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigOpenBlossomMarkInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_open_all: self.open_all = self._io.read_u1() @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_open_all(self): if hasattr(self, '_m_has_field_open_all'): return self._m_has_field_open_all self._m_has_field_open_all = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_open_all', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class TransPointRewardConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HashUtils(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2projectionSwitchButtonConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_text_id: self.text_id = AuxTypes.String(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_text_id(self): if hasattr(self, '_m_has_field_text_id'): return self._m_has_field_text_id self._m_has_field_text_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_text_id', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon_path', None) class KvpOfDictAuxTypesStringConfigSkipUnindexedEffectCreation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigSkipUnindexedEffectCreation(self._io, self, self._root) class BlossomReviseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grade: self.grade = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_grade(self): if hasattr(self, '_m_has_field_grade'): return self._m_has_field_grade self._m_has_field_grade = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_grade', None) class ConfigGuideAnchorUnlockCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock: self.unlock = self._io.read_u1() @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_id', None) @property def has_field_unlock(self): if hasattr(self, '_m_has_field_unlock'): return self._m_has_field_unlock self._m_has_field_unlock = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_unlock', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class MoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityPushTipsConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_subtitle: self.subtitle = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_icon: self.show_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_tab_icon: self.tab_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_immediately: self.show_immediately = self._io.read_u1() if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_subtitle(self): if hasattr(self, '_m_has_field_subtitle'): return self._m_has_field_subtitle self._m_has_field_subtitle = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_subtitle', None) @property def has_field_show_icon(self): if hasattr(self, '_m_has_field_show_icon'): return self._m_has_field_show_icon self._m_has_field_show_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_show_icon', None) @property def has_field_show_immediately(self): if hasattr(self, '_m_has_field_show_immediately'): return self._m_has_field_show_immediately self._m_has_field_show_immediately = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_immediately', None) @property def has_field_tab_icon(self): if hasattr(self, '_m_has_field_tab_icon'): return self._m_has_field_tab_icon self._m_has_field_tab_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tab_icon', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) class ActivityBannerExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_banner_type: self.banner_type = Output.EnumActivityBannerType(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_config_name: self.json_config_name = AuxTypes.String(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_show_desc: self.show_desc = self._io.read_u1() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_show_desc(self): if hasattr(self, '_m_has_field_show_desc'): return self._m_has_field_show_desc self._m_has_field_show_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_desc', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_json_config_name(self): if hasattr(self, '_m_has_field_json_config_name'): return self._m_has_field_json_config_name self._m_has_field_json_config_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_json_config_name', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_prefab_path', None) @property def has_field_banner_type(self): if hasattr(self, '_m_has_field_banner_type'): return self._m_has_field_banner_type self._m_has_field_banner_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_banner_type', None) class ContextActionExecuteAll(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_actions: self.actions = Output.ArrayOfDispContextActionLengthU(self._io, self, self._root) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_actions', None) class TileComplexMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_id: self.attack_id = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_point_name: self.attach_point_name = AuxTypes.String(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_shape: self.shape = Output.DispTileShapeInfo(self._io, self, self._root) @property def has_field_shape(self): if hasattr(self, '_m_has_field_shape'): return self._m_has_field_shape self._m_has_field_shape = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_shape', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_attack_id(self): if hasattr(self, '_m_has_field_attack_id'): return self._m_has_field_attack_id self._m_has_field_attack_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_id', None) @property def has_field_attach_point_name(self): if hasattr(self, '_m_has_field_attach_point_name'): return self._m_has_field_attach_point_name self._m_has_field_attach_point_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_point_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WorldExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumWorldType(self._io, self, self._root) if self.has_field_main_scene_id: self.main_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_scene_id_vec: self.sub_scene_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_main_scene_id(self): if hasattr(self, '_m_has_field_main_scene_id'): return self._m_has_field_main_scene_id self._m_has_field_main_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_main_scene_id', None) @property def has_field_sub_scene_id_vec(self): if hasattr(self, '_m_has_field_sub_scene_id_vec'): return self._m_has_field_sub_scene_id_vec self._m_has_field_sub_scene_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sub_scene_id_vec', None) class ConfigAiMixinSetAnimatorTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trigger_id: self.trigger_id = AuxTypes.String(self._io, self, self._root) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_id', None) class ConfigGuidePauseAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) class TutorialExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detail_id_list: self.detail_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pause_game: self.pause_game = self._io.read_u1() if self.has_field_is_multi_platform: self.is_multi_platform = self._io.read_u1() if self.has_field_mobile_detail_id_list: self.mobile_detail_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_joypad_detail_id_list: self.joypad_detail_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_mobile_detail_id_list(self): if hasattr(self, '_m_has_field_mobile_detail_id_list'): return self._m_has_field_mobile_detail_id_list self._m_has_field_mobile_detail_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mobile_detail_id_list', None) @property def has_field_detail_id_list(self): if hasattr(self, '_m_has_field_detail_id_list'): return self._m_has_field_detail_id_list self._m_has_field_detail_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_detail_id_list', None) @property def has_field_joypad_detail_id_list(self): if hasattr(self, '_m_has_field_joypad_detail_id_list'): return self._m_has_field_joypad_detail_id_list self._m_has_field_joypad_detail_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_joypad_detail_id_list', None) @property def has_field_is_multi_platform(self): if hasattr(self, '_m_has_field_is_multi_platform'): return self._m_has_field_is_multi_platform self._m_has_field_is_multi_platform = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_multi_platform', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_pause_game(self): if hasattr(self, '_m_has_field_pause_game'): return self._m_has_field_pause_game self._m_has_field_pause_game = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pause_game', None) class OnParentAbilityStartMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_list: self.action_list = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class AddAvatarSkillInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class BlitzRushExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DecisionArchetypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigWorldAreaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigWorldArea(self._io, self, self._root)) class CoopCgExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_point_id: self.unlock_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cg_type: self.cg_type = Output.EnumCoopCgType(self._io, self, self._root) if self.has_field_unlock_cond: self.unlock_cond = Output.ArrayOfCoopCondConfigLengthS(self._io, self, self._root) if self.has_field_show_image_hash: self.show_image_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_image_hash: self.show_image_hash_pre = self._io.read_s1() if self.has_field_show_image_small_hash: self.show_image_small_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_image_small_hash: self.show_image_small_hash_pre = self._io.read_s1() if self.has_field_cg_name: self.cg_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cg_des: self.cg_des = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_sort_id', None) @property def has_field_cg_type(self): if hasattr(self, '_m_has_field_cg_type'): return self._m_has_field_cg_type self._m_has_field_cg_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cg_type', None) @property def has_field_show_image_hash(self): if hasattr(self, '_m_has_field_show_image_hash'): return self._m_has_field_show_image_hash self._m_has_field_show_image_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_image_hash', None) @property def has_field_cg_des(self): if hasattr(self, '_m_has_field_cg_des'): return self._m_has_field_cg_des self._m_has_field_cg_des = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cg_des', None) @property def has_field_cg_name(self): if hasattr(self, '_m_has_field_cg_name'): return self._m_has_field_cg_name self._m_has_field_cg_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cg_name', None) @property def has_field_unlock_point_id(self): if hasattr(self, '_m_has_field_unlock_point_id'): return self._m_has_field_unlock_point_id self._m_has_field_unlock_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_point_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_show_image_small_hash(self): if hasattr(self, '_m_has_field_show_image_small_hash'): return self._m_has_field_show_image_small_hash self._m_has_field_show_image_small_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_image_small_hash', None) @property def has_field_unlock_cond(self): if hasattr(self, '_m_has_field_unlock_cond'): return self._m_has_field_unlock_cond self._m_has_field_unlock_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_cond', None) class EnumGachaItemParentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GachaItemParentType, self.data.value) return getattr(self, '_m_value', None) class ActivityArenaChallengeChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigMassiveEntityElementLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMassiveEntityElement(self._io, self, self._root)) class FixedMonsterRushMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_time_range: self.time_range = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_range: self.max_range = self._io.read_f4le() if self.has_field_animator_state_i_ds: self.animator_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_override_move_collider: self.override_move_collider = AuxTypes.String(self._io, self, self._root) if self.has_field_is_in_air: self.is_in_air = self._io.read_u1() if self.has_field_check_animator_state_on_exit_only: self.check_animator_state_on_exit_only = self._io.read_u1() if self.has_field_ignore_detect_forward: self.ignore_detect_forward = self._io.read_u1() if self.has_field_exact_arrive: self.exact_arrive = self._io.read_u1() @property def has_field_time_range(self): if hasattr(self, '_m_has_field_time_range'): return self._m_has_field_time_range self._m_has_field_time_range = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_time_range', None) @property def has_field_ignore_detect_forward(self): if hasattr(self, '_m_has_field_ignore_detect_forward'): return self._m_has_field_ignore_detect_forward self._m_has_field_ignore_detect_forward = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_ignore_detect_forward', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_max_range(self): if hasattr(self, '_m_has_field_max_range'): return self._m_has_field_max_range self._m_has_field_max_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_max_range', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_exact_arrive(self): if hasattr(self, '_m_has_field_exact_arrive'): return self._m_has_field_exact_arrive self._m_has_field_exact_arrive = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_exact_arrive', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_is_in_air(self): if hasattr(self, '_m_has_field_is_in_air'): return self._m_has_field_is_in_air self._m_has_field_is_in_air = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_is_in_air', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_animator_state_i_ds(self): if hasattr(self, '_m_has_field_animator_state_i_ds'): return self._m_has_field_animator_state_i_ds self._m_has_field_animator_state_i_ds = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_animator_state_i_ds', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_move_collider(self): if hasattr(self, '_m_has_field_override_move_collider'): return self._m_has_field_override_move_collider self._m_has_field_override_move_collider = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_override_move_collider', None) @property def has_field_check_animator_state_on_exit_only(self): if hasattr(self, '_m_has_field_check_animator_state_on_exit_only'): return self._m_has_field_check_animator_state_on_exit_only self._m_has_field_check_animator_state_on_exit_only = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_check_animator_state_on_exit_only', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_to_pos', None) class SetAnimatorFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_float_id: self.float_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_persistent: self.persistent = self._io.read_u1() if self.has_field_use_random_value: self.use_random_value = self._io.read_u1() if self.has_field_random_value_min: self.random_value_min = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_random_value_max: self.random_value_max = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_transition_time: self.transition_time = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_transition_time(self): if hasattr(self, '_m_has_field_transition_time'): return self._m_has_field_transition_time self._m_has_field_transition_time = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_transition_time', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_persistent(self): if hasattr(self, '_m_has_field_persistent'): return self._m_has_field_persistent self._m_has_field_persistent = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_persistent', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_use_random_value(self): if hasattr(self, '_m_has_field_use_random_value'): return self._m_has_field_use_random_value self._m_has_field_use_random_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_random_value', None) @property def has_field_random_value_max(self): if hasattr(self, '_m_has_field_random_value_max'): return self._m_has_field_random_value_max self._m_has_field_random_value_max = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_random_value_max', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_float_id(self): if hasattr(self, '_m_has_field_float_id'): return self._m_has_field_float_id self._m_has_field_float_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_float_id', None) @property def has_field_random_value_min(self): if hasattr(self, '_m_has_field_random_value_min'): return self._m_has_field_random_value_min self._m_has_field_random_value_min = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_random_value_min', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class BuffIconExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_mutex_type: self.mutex_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_buff_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_mutex_type(self): if hasattr(self, '_m_has_field_mutex_type'): return self._m_has_field_mutex_type self._m_has_field_mutex_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_mutex_type', None) class ConfigAudioCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_camera_pitch_rtpc_key: self.camera_pitch_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_camera_pitch_rtpc_key(self): if hasattr(self, '_m_has_field_camera_pitch_rtpc_key'): return self._m_has_field_camera_pitch_rtpc_key self._m_has_field_camera_pitch_rtpc_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_pitch_rtpc_key', None) class EnumProductPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProductPlayType, self.data.value) return getattr(self, '_m_value', None) class ByIsMoveOnWater(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class HuntingRefreshExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigBattleFervorUpdateTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBattleFervorUpdateTrigger(self._io, self, self._root)) class SelfAddDurabilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_think_interval: self.think_interval = self._io.read_f4le() @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_think_interval(self): if hasattr(self, '_m_has_field_think_interval'): return self._m_has_field_think_interval self._m_has_field_think_interval = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_think_interval', None) class SetLogicStateValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_logic_state_name: self.logic_state_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_logic_state_name(self): if hasattr(self, '_m_has_field_logic_state_name'): return self._m_has_field_logic_state_name self._m_has_field_logic_state_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_logic_state_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class LocalizationExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryTiredTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigTimeProtectAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfSectrBakeLayerInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrBakeLayerInfo(self._io, self, self._root)) class ConfigPreload(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effects: self.effects = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_abilities: self.abilities = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_gadgets: self.gadgets = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_cameras: self.cameras = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_anim_event_patterns: self.anim_event_patterns = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_skill_icons: self.skill_icons = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_misc_obj_paths: self.misc_obj_paths = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_weathers: self.weathers = Output.DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_cameras(self): if hasattr(self, '_m_has_field_cameras'): return self._m_has_field_cameras self._m_has_field_cameras = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cameras', None) @property def has_field_gadgets(self): if hasattr(self, '_m_has_field_gadgets'): return self._m_has_field_gadgets self._m_has_field_gadgets = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_gadgets', None) @property def has_field_weathers(self): if hasattr(self, '_m_has_field_weathers'): return self._m_has_field_weathers self._m_has_field_weathers = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_weathers', None) @property def has_field_abilities(self): if hasattr(self, '_m_has_field_abilities'): return self._m_has_field_abilities self._m_has_field_abilities = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_abilities', None) @property def has_field_skill_icons(self): if hasattr(self, '_m_has_field_skill_icons'): return self._m_has_field_skill_icons self._m_has_field_skill_icons = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_skill_icons', None) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effects', None) @property def has_field_misc_obj_paths(self): if hasattr(self, '_m_has_field_misc_obj_paths'): return self._m_has_field_misc_obj_paths self._m_has_field_misc_obj_paths = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_misc_obj_paths', None) @property def has_field_anim_event_patterns(self): if hasattr(self, '_m_has_field_anim_event_patterns'): return self._m_has_field_anim_event_patterns self._m_has_field_anim_event_patterns = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_anim_event_patterns', None) class ByCurrentSceneTypes(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scene_types: self.scene_types = Output.ArrayOfEnumSceneTypeLengthU(self._io, self, self._root) @property def has_field_scene_types(self): if hasattr(self, '_m_has_field_scene_types'): return self._m_has_field_scene_types self._m_has_field_scene_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_types', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class RoguelikeCursePoolExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDeliveryQuestConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DeliveryQuestConfig(self._io, self, self._root)) class RogueDiaryResourceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioEventOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioOperation(self._io, self, self._root) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class ConfigBaseContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_action_groups: self.action_groups = Output.DictOfAuxTypesStringArrayOfInputActionEventLengthU(self._io, self, self._root) if self.has_field_state_actions: self.state_actions = Output.DictOfAuxTypesVlqBase128LeSDeviceAction(self._io, self, self._root) if self.has_field_enable_input_penetrate: self.enable_input_penetrate = self._io.read_u1() if self.has_field_enable_joypad_virtual_cursor: self.enable_joypad_virtual_cursor = self._io.read_u1() @property def has_field_action_groups(self): if hasattr(self, '_m_has_field_action_groups'): return self._m_has_field_action_groups self._m_has_field_action_groups = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_groups', None) @property def has_field_state_actions(self): if hasattr(self, '_m_has_field_state_actions'): return self._m_has_field_state_actions self._m_has_field_state_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_actions', None) @property def has_field_enable_input_penetrate(self): if hasattr(self, '_m_has_field_enable_input_penetrate'): return self._m_has_field_enable_input_penetrate self._m_has_field_enable_input_penetrate = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_enable_input_penetrate', None) @property def has_field_enable_joypad_virtual_cursor(self): if hasattr(self, '_m_has_field_enable_joypad_virtual_cursor'): return self._m_has_field_enable_joypad_virtual_cursor self._m_has_field_enable_joypad_virtual_cursor = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enable_joypad_virtual_cursor', None) class KvpOfDictEnumNpcBodyTypeFirstPersonCoopCamConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumNpcBodyType(self._io, self, self._root) self.value = Output.FirstPersonCoopCamConfig(self._io, self, self._root) class ArrayOfCoolDownInfoLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CoolDownInfo(self._io, self, self._root)) class HuntingGroupInfoExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetGlobalValueList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_list: self.global_value_list = Output.ArrayOfGlobalValuePairLengthU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_global_value_list(self): if hasattr(self, '_m_has_field_global_value_list'): return self._m_has_field_global_value_list self._m_has_field_global_value_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_list', None) class ConfigSceneArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumSceneAreaType(self._io, self, self._root) if self.has_field_unlocked: self.unlocked = self._io.read_u1() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_unlocked(self): if hasattr(self, '_m_has_field_unlocked'): return self._m_has_field_unlocked self._m_has_field_unlocked = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_unlocked', None) class TutorialDetailTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDefaultAbilities(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monter_elite_ability_name: self.monter_elite_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_non_humanoid_move_abilities: self.non_humanoid_move_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_default_abilities: self.level_default_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_element_abilities: self.level_element_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_item_abilities: self.level_item_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_level_s_buff_abilities: self.level_s_buff_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_dungeon_abilities: self.dungeon_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_default_team_abilities: self.default_team_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_default_mp_level_abilities: self.default_mp_level_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_default_avatar_abilities: self.default_avatar_abilities = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_level_default_abilities(self): if hasattr(self, '_m_has_field_level_default_abilities'): return self._m_has_field_level_default_abilities self._m_has_field_level_default_abilities = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_level_default_abilities', None) @property def has_field_level_element_abilities(self): if hasattr(self, '_m_has_field_level_element_abilities'): return self._m_has_field_level_element_abilities self._m_has_field_level_element_abilities = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_level_element_abilities', None) @property def has_field_level_s_buff_abilities(self): if hasattr(self, '_m_has_field_level_s_buff_abilities'): return self._m_has_field_level_s_buff_abilities self._m_has_field_level_s_buff_abilities = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_level_s_buff_abilities', None) @property def has_field_non_humanoid_move_abilities(self): if hasattr(self, '_m_has_field_non_humanoid_move_abilities'): return self._m_has_field_non_humanoid_move_abilities self._m_has_field_non_humanoid_move_abilities = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_non_humanoid_move_abilities', None) @property def has_field_default_avatar_abilities(self): if hasattr(self, '_m_has_field_default_avatar_abilities'): return self._m_has_field_default_avatar_abilities self._m_has_field_default_avatar_abilities = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_default_avatar_abilities', None) @property def has_field_monter_elite_ability_name(self): if hasattr(self, '_m_has_field_monter_elite_ability_name'): return self._m_has_field_monter_elite_ability_name self._m_has_field_monter_elite_ability_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_monter_elite_ability_name', None) @property def has_field_level_item_abilities(self): if hasattr(self, '_m_has_field_level_item_abilities'): return self._m_has_field_level_item_abilities self._m_has_field_level_item_abilities = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_level_item_abilities', None) @property def has_field_default_team_abilities(self): if hasattr(self, '_m_has_field_default_team_abilities'): return self._m_has_field_default_team_abilities self._m_has_field_default_team_abilities = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_default_team_abilities', None) @property def has_field_default_mp_level_abilities(self): if hasattr(self, '_m_has_field_default_mp_level_abilities'): return self._m_has_field_default_mp_level_abilities self._m_has_field_default_mp_level_abilities = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_default_mp_level_abilities', None) @property def has_field_dungeon_abilities(self): if hasattr(self, '_m_has_field_dungeon_abilities'): return self._m_has_field_dungeon_abilities self._m_has_field_dungeon_abilities = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_dungeon_abilities', None) class CommonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHandbookQuestGuideShowCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HandbookQuestGuideShowCondType, self.data.value) return getattr(self, '_m_value', None) class EnumCutsceneIndexType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CutsceneIndexType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetIconBillboard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBillboard(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) @property def offset_type(self): if hasattr(self, '_m_offset_type'): return self._m_offset_type self._m_offset_type = self.base.offset_type return getattr(self, '_m_offset_type', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_icon_name', None) @property def show_distance(self): if hasattr(self, '_m_show_distance'): return self._m_show_distance self._m_show_distance = self.base.show_distance return getattr(self, '_m_show_distance', None) @property def radius_offset(self): if hasattr(self, '_m_radius_offset'): return self._m_radius_offset self._m_radius_offset = self.base.radius_offset return getattr(self, '_m_radius_offset', None) @property def name_show_distance(self): if hasattr(self, '_m_name_show_distance'): return self._m_name_show_distance self._m_name_show_distance = self.base.name_show_distance return getattr(self, '_m_name_show_distance', None) @property def enable_self_adapt(self): if hasattr(self, '_m_enable_self_adapt'): return self._m_enable_self_adapt self._m_enable_self_adapt = self.base.enable_self_adapt return getattr(self, '_m_enable_self_adapt', None) @property def mark_show_distance(self): if hasattr(self, '_m_mark_show_distance'): return self._m_mark_show_distance self._m_mark_show_distance = self.base.mark_show_distance return getattr(self, '_m_mark_show_distance', None) @property def attach_point(self): if hasattr(self, '_m_attach_point'): return self._m_attach_point self._m_attach_point = self.base.attach_point return getattr(self, '_m_attach_point', None) @property def force_hide_all_bars(self): if hasattr(self, '_m_force_hide_all_bars'): return self._m_force_hide_all_bars self._m_force_hide_all_bars = self.base.force_hide_all_bars return getattr(self, '_m_force_hide_all_bars', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ActivityShopOverallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) if self.has_field_sheet_list: self.sheet_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_sheet_list(self): if hasattr(self, '_m_has_field_sheet_list'): return self._m_has_field_sheet_list self._m_has_field_sheet_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sheet_list', None) class LanV2fireworksStageDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id_list: self.challenge_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tab_name: self.tab_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_guide_quest_reward_preview_id: self.guide_quest_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_challenge_id_list(self): if hasattr(self, '_m_has_field_challenge_id_list'): return self._m_has_field_challenge_id_list self._m_has_field_challenge_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_challenge_id_list', None) @property def has_field_tab_name(self): if hasattr(self, '_m_has_field_tab_name'): return self._m_has_field_tab_name self._m_has_field_tab_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tab_name', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_guide_quest_reward_preview_id(self): if hasattr(self, '_m_has_field_guide_quest_reward_preview_id'): return self._m_has_field_guide_quest_reward_preview_id self._m_has_field_guide_quest_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_guide_quest_reward_preview_id', None) class ReunionPrivilegeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumReunionPrivilegeType(self._io, self, self._root) if self.has_field_sub_type: self.sub_type = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_sub_type(self): if hasattr(self, '_m_has_field_sub_type'): return self._m_has_field_sub_type self._m_has_field_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_type', None) class HotFixPatchMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigLinerBulletMove(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigFollowMove(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigPinballBulletMove(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigMove(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigVehicleMove(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigPlatformMove(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigTrackBulletMove(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigScenePropAnimatorMove(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigSimpleMove(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigNpcMove(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigBoatMove(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigSkiffMove(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigFormulaicMove(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigAnimatorMove(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigFishingAimParabolaBulletMove(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigLinerParabolaBulletMove(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigAnimationBulletMove(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigWindmillMove(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigBulletMove(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigItanoCircusBulletMove(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigSurroundBulletMove(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigParabolaBulletMove(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigRigidbodyMove(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigMultiBulletMove(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DispConfigQteStepBaseCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigQteStepBaseCond(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigQteStepPowerBarCond(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigQteButtonCountDownValueCond(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigKeyboardLayout(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_keyboard_layouts: self.config_keyboard_layouts = Output.DictOfEnumKeyboardTypeConfigKeyboardLayoutItem(self._io, self, self._root) if self.has_field_input_action_type_groups: self.input_action_type_groups = Output.DictOfEnumInputActionGroupTypeArrayOfEnumInputActionTypeLengthU(self._io, self, self._root) @property def has_field_config_keyboard_layouts(self): if hasattr(self, '_m_has_field_config_keyboard_layouts'): return self._m_has_field_config_keyboard_layouts self._m_has_field_config_keyboard_layouts = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_keyboard_layouts', None) @property def has_field_input_action_type_groups(self): if hasattr(self, '_m_has_field_input_action_type_groups'): return self._m_has_field_input_action_type_groups self._m_has_field_input_action_type_groups = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_input_action_type_groups', None) class EnumSsaoMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SsaoMode, self.data.value) return getattr(self, '_m_value', None) class EchoShellFloatSignalExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityDeliveryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IndicatorConditionSceneTransPointLockState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_unlocked: self.unlocked = self._io.read_u1() @property def has_field_unlocked(self): if hasattr(self, '_m_has_field_unlocked'): return self._m_has_field_unlocked self._m_has_field_unlocked = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_unlocked', None) class NewActivityWatcherConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview: self.reward_preview = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activitychallengetips: self.activitychallengetips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_activitychallengetips: self.extra_activitychallengetips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_auto_grant: self.is_auto_grant = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_reward_preview(self): if hasattr(self, '_m_has_field_reward_preview'): return self._m_has_field_reward_preview self._m_has_field_reward_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_preview', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_is_auto_grant(self): if hasattr(self, '_m_has_field_is_auto_grant'): return self._m_has_field_is_auto_grant self._m_has_field_is_auto_grant = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_auto_grant', None) @property def has_field_activitychallengetips(self): if hasattr(self, '_m_has_field_activitychallengetips'): return self._m_has_field_activitychallengetips self._m_has_field_activitychallengetips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activitychallengetips', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_extra_activitychallengetips(self): if hasattr(self, '_m_has_field_extra_activitychallengetips'): return self._m_has_field_extra_activitychallengetips self._m_has_field_extra_activitychallengetips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_extra_activitychallengetips', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ArrayOfItemUseConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ItemUseConfig(self._io, self, self._root)) class FetterConditionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumFetterCondType(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_list', None) class ArrayOfConfigLevelNavmeshPolygonLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelNavmeshPolygon(self._io, self, self._root)) class ArrayOfEnumTextParamTypeLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumTextParamType(self._io, self, self._root)) class KvpOfDictAuxTypesStringConfigActionPanelState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigActionPanelState(self._io, self, self._root) class EnumVehicleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VehicleType, self.data.value) return getattr(self, '_m_value', None) class EnumDisplayItemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DisplayItemType, self.data.value) return getattr(self, '_m_value', None) class ConfigAudioResource(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sound_bank_package_name: self.sound_bank_package_name = AuxTypes.String(self._io, self, self._root) if self.has_field_external_source_package_name: self.external_source_package_name = AuxTypes.String(self._io, self, self._root) if self.has_field_streamed_music_package_name: self.streamed_music_package_name = AuxTypes.String(self._io, self, self._root) if self.has_field_streamed_file_package_name: self.streamed_file_package_name = AuxTypes.String(self._io, self, self._root) if self.has_field_n_sound_bank_split_bits: self.n_sound_bank_split_bits = self._io.read_u1() if self.has_field_n_external_source_split_bits: self.n_external_source_split_bits = self._io.read_u1() if self.has_field_n_streamed_music_split_bits: self.n_streamed_music_split_bits = self._io.read_u1() if self.has_field_n_streamed_file_split_bits: self.n_streamed_file_split_bits = self._io.read_u1() if self.has_field_package_file_extension: self.package_file_extension = AuxTypes.String(self._io, self, self._root) if self.has_field_incrementals: self.incrementals = Output.DictOfAuxTypesStringConfigAudioIncrementalResources(self._io, self, self._root) @property def has_field_external_source_package_name(self): if hasattr(self, '_m_has_field_external_source_package_name'): return self._m_has_field_external_source_package_name self._m_has_field_external_source_package_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_external_source_package_name', None) @property def has_field_n_streamed_music_split_bits(self): if hasattr(self, '_m_has_field_n_streamed_music_split_bits'): return self._m_has_field_n_streamed_music_split_bits self._m_has_field_n_streamed_music_split_bits = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_n_streamed_music_split_bits', None) @property def has_field_sound_bank_package_name(self): if hasattr(self, '_m_has_field_sound_bank_package_name'): return self._m_has_field_sound_bank_package_name self._m_has_field_sound_bank_package_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_sound_bank_package_name', None) @property def has_field_streamed_music_package_name(self): if hasattr(self, '_m_has_field_streamed_music_package_name'): return self._m_has_field_streamed_music_package_name self._m_has_field_streamed_music_package_name = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_streamed_music_package_name', None) @property def has_field_streamed_file_package_name(self): if hasattr(self, '_m_has_field_streamed_file_package_name'): return self._m_has_field_streamed_file_package_name self._m_has_field_streamed_file_package_name = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_streamed_file_package_name', None) @property def has_field_n_external_source_split_bits(self): if hasattr(self, '_m_has_field_n_external_source_split_bits'): return self._m_has_field_n_external_source_split_bits self._m_has_field_n_external_source_split_bits = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_n_external_source_split_bits', None) @property def has_field_incrementals(self): if hasattr(self, '_m_has_field_incrementals'): return self._m_has_field_incrementals self._m_has_field_incrementals = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_incrementals', None) @property def has_field_package_file_extension(self): if hasattr(self, '_m_has_field_package_file_extension'): return self._m_has_field_package_file_extension self._m_has_field_package_file_extension = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_package_file_extension', None) @property def has_field_n_streamed_file_split_bits(self): if hasattr(self, '_m_has_field_n_streamed_file_split_bits'): return self._m_has_field_n_streamed_file_split_bits self._m_has_field_n_streamed_file_split_bits = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_n_streamed_file_split_bits', None) @property def has_field_n_sound_bank_split_bits(self): if hasattr(self, '_m_has_field_n_sound_bank_split_bits'): return self._m_has_field_n_sound_bank_split_bits self._m_has_field_n_sound_bank_split_bits = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_n_sound_bank_split_bits', None) class DictOfEnumPerfRatingCategoryAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPerfRatingCategoryAuxTypesVlqBase128LeS(self._io, self, self._root)) class ConfigVodPlayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_vod_player_type: self.vod_player_type = Output.EnumVodPlayerType(self._io, self, self._root) @property def has_field_vod_player_type(self): if hasattr(self, '_m_has_field_vod_player_type'): return self._m_has_field_vod_player_type self._m_has_field_vod_player_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_vod_player_type', None) class ActivityGachaRobotComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExhibitionListDisplayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLivePlayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigVodPlayer(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_live_id: self.live_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_turn_on_radius: self.turn_on_radius = self._io.read_f4le() if self.has_field_turn_off_radius: self.turn_off_radius = self._io.read_f4le() if self.has_field_cue_point_ability_map: self.cue_point_ability_map = Output.DictOfAuxTypesVlqBase128LeUAuxTypesString(self._io, self, self._root) @property def has_field_live_id(self): if hasattr(self, '_m_has_field_live_id'): return self._m_has_field_live_id self._m_has_field_live_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_live_id', None) @property def has_field_turn_off_radius(self): if hasattr(self, '_m_has_field_turn_off_radius'): return self._m_has_field_turn_off_radius self._m_has_field_turn_off_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_turn_off_radius', None) @property def has_field_cue_point_ability_map(self): if hasattr(self, '_m_has_field_cue_point_ability_map'): return self._m_has_field_cue_point_ability_map self._m_has_field_cue_point_ability_map = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cue_point_ability_map', None) @property def has_field_turn_on_radius(self): if hasattr(self, '_m_has_field_turn_on_radius'): return self._m_has_field_turn_on_radius self._m_has_field_turn_on_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_on_radius', None) @property def vod_player_type(self): if hasattr(self, '_m_vod_player_type'): return self._m_vod_player_type self._m_vod_player_type = self.base.vod_player_type return getattr(self, '_m_vod_player_type', None) class TileShapeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FoodQualityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityAppearVisionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfNumberArrayItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfNumberArrayItemOverrideInfo(self._io, self, self._root) class KvpOfDictAuxTypesStringArrayOfF4LengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfF4LengthU(self._io, self, self._root) class CustomLevelComponentConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GrowCurveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FlightActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward_id: self.preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_quest_id: self.start_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_medal_id: self.medal_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_daily_factor_vec: self.daily_factor_vec = Output.ArrayOfFlightDailyPointFactorLengthS(self._io, self, self._root) @property def has_field_start_quest_id(self): if hasattr(self, '_m_has_field_start_quest_id'): return self._m_has_field_start_quest_id self._m_has_field_start_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_start_quest_id', None) @property def has_field_medal_id(self): if hasattr(self, '_m_has_field_medal_id'): return self._m_has_field_medal_id self._m_has_field_medal_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_medal_id', None) @property def has_field_daily_factor_vec(self): if hasattr(self, '_m_has_field_daily_factor_vec'): return self._m_has_field_daily_factor_vec self._m_has_field_daily_factor_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_daily_factor_vec', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_preview_reward_id(self): if hasattr(self, '_m_has_field_preview_reward_id'): return self._m_has_field_preview_reward_id self._m_has_field_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_preview_reward_id', None) class EnableWeatherLock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesVlqBase128LeSConfigAiSpacialAdjustData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialAdjustData(self._io, self, self._root)) class MichiaeRadarExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mark_type: self.mark_type = Output.EnumMichiaeMatsuriRadarMarkType(self._io, self, self._root) if self.has_field_gadget_id_list: self.gadget_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_mark_type(self): if hasattr(self, '_m_has_field_mark_type'): return self._m_has_field_mark_type self._m_has_field_mark_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mark_type', None) @property def has_field_gadget_id_list(self): if hasattr(self, '_m_has_field_gadget_id_list'): return self._m_has_field_gadget_id_list self._m_has_field_gadget_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id_list', None) class TalkExec(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumTalkExecType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ByElementReactionSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_source_type: self.source_type = Output.EnumElementReactionSourceType(self._io, self, self._root) @property def has_field_source_type(self): if hasattr(self, '_m_has_field_source_type'): return self._m_has_field_source_type self._m_has_field_source_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_source_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigSetModelTransform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_reset: self.is_reset = self._io.read_u1() if self.has_field_groud_hight: self.groud_hight = self._io.read_f4le() @property def has_field_groud_hight(self): if hasattr(self, '_m_has_field_groud_hight'): return self._m_has_field_groud_hight self._m_has_field_groud_hight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_groud_hight', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_is_reset(self): if hasattr(self, '_m_has_field_is_reset'): return self._m_has_field_is_reset self._m_has_field_is_reset = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_reset', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class WidgetBusinessTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessCardEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerWeatherTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetDigScanner(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetToyCreateGadgetBase(self._io, self, self._root) @property def is_set_camera(self): if hasattr(self, '_m_is_set_camera'): return self._m_is_set_camera self._m_is_set_camera = self.base.is_set_camera return getattr(self, '_m_is_set_camera', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def set_camera_angle(self): if hasattr(self, '_m_set_camera_angle'): return self._m_set_camera_angle self._m_set_camera_angle = self.base.set_camera_angle return getattr(self, '_m_set_camera_angle', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def do_bag_type(self): if hasattr(self, '_m_do_bag_type'): return self._m_do_bag_type self._m_do_bag_type = self.base.do_bag_type return getattr(self, '_m_do_bag_type', None) class KvpOfDictEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumConfigPreloadType(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) class AvatarEnterFocus(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_follow_lower: self.camera_follow_lower = Output.Vector(self._io, self, self._root) if self.has_field_camera_follow_upper: self.camera_follow_upper = Output.Vector(self._io, self, self._root) if self.has_field_camera_follow_max_degree: self.camera_follow_max_degree = self._io.read_f4le() if self.has_field_camera_follow_min_degree: self.camera_follow_min_degree = self._io.read_f4le() if self.has_field_camera_fast_focus_mode: self.camera_fast_focus_mode = self._io.read_u1() if self.has_field_face_to_target: self.face_to_target = self._io.read_u1() if self.has_field_face_to_target_angle_threshold: self.face_to_target_angle_threshold = self._io.read_f4le() if self.has_field_change_main_skill_id: self.change_main_skill_id = self._io.read_u1() if self.has_field_drag_button_name: self.drag_button_name = AuxTypes.String(self._io, self, self._root) if self.has_field_assistance: self.assistance = Output.FocusAssistanceGroup(self._io, self, self._root) if self.has_field_can_move: self.can_move = self._io.read_u1() if self.has_field_show_crosshair: self.show_crosshair = self._io.read_u1() if self.has_field_vcam_fov: self.vcam_fov = self._io.read_f4le() if self.has_field_focus_anchor_hor_angle: self.focus_anchor_hor_angle = self._io.read_f4le() if self.has_field_focus_anchor_ver_angle: self.focus_anchor_ver_angle = self._io.read_f4le() if self.has_field_disable_anim: self.disable_anim = self._io.read_u1() if self.has_field_disable_aim_layer: self.disable_aim_layer = self._io.read_u1() @property def has_field_vcam_fov(self): if hasattr(self, '_m_has_field_vcam_fov'): return self._m_has_field_vcam_fov self._m_has_field_vcam_fov = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_vcam_fov', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_change_main_skill_id(self): if hasattr(self, '_m_has_field_change_main_skill_id'): return self._m_has_field_change_main_skill_id self._m_has_field_change_main_skill_id = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_change_main_skill_id', None) @property def has_field_camera_follow_min_degree(self): if hasattr(self, '_m_has_field_camera_follow_min_degree'): return self._m_has_field_camera_follow_min_degree self._m_has_field_camera_follow_min_degree = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_camera_follow_min_degree', None) @property def has_field_disable_anim(self): if hasattr(self, '_m_has_field_disable_anim'): return self._m_has_field_disable_anim self._m_has_field_disable_anim = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_disable_anim', None) @property def has_field_show_crosshair(self): if hasattr(self, '_m_has_field_show_crosshair'): return self._m_has_field_show_crosshair self._m_has_field_show_crosshair = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_show_crosshair', None) @property def has_field_camera_fast_focus_mode(self): if hasattr(self, '_m_has_field_camera_fast_focus_mode'): return self._m_has_field_camera_fast_focus_mode self._m_has_field_camera_fast_focus_mode = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_camera_fast_focus_mode', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_camera_follow_max_degree(self): if hasattr(self, '_m_has_field_camera_follow_max_degree'): return self._m_has_field_camera_follow_max_degree self._m_has_field_camera_follow_max_degree = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_camera_follow_max_degree', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_drag_button_name(self): if hasattr(self, '_m_has_field_drag_button_name'): return self._m_has_field_drag_button_name self._m_has_field_drag_button_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_drag_button_name', None) @property def has_field_can_move(self): if hasattr(self, '_m_has_field_can_move'): return self._m_has_field_can_move self._m_has_field_can_move = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_can_move', None) @property def has_field_focus_anchor_hor_angle(self): if hasattr(self, '_m_has_field_focus_anchor_hor_angle'): return self._m_has_field_focus_anchor_hor_angle self._m_has_field_focus_anchor_hor_angle = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_focus_anchor_hor_angle', None) @property def has_field_assistance(self): if hasattr(self, '_m_has_field_assistance'): return self._m_has_field_assistance self._m_has_field_assistance = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_assistance', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_disable_aim_layer(self): if hasattr(self, '_m_has_field_disable_aim_layer'): return self._m_has_field_disable_aim_layer self._m_has_field_disable_aim_layer = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_disable_aim_layer', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_face_to_target_angle_threshold(self): if hasattr(self, '_m_has_field_face_to_target_angle_threshold'): return self._m_has_field_face_to_target_angle_threshold self._m_has_field_face_to_target_angle_threshold = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_face_to_target_angle_threshold', None) @property def has_field_face_to_target(self): if hasattr(self, '_m_has_field_face_to_target'): return self._m_has_field_face_to_target self._m_has_field_face_to_target = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_face_to_target', None) @property def has_field_camera_follow_upper(self): if hasattr(self, '_m_has_field_camera_follow_upper'): return self._m_has_field_camera_follow_upper self._m_has_field_camera_follow_upper = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_camera_follow_upper', None) @property def has_field_camera_follow_lower(self): if hasattr(self, '_m_has_field_camera_follow_lower'): return self._m_has_field_camera_follow_lower self._m_has_field_camera_follow_lower = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_camera_follow_lower', None) @property def has_field_focus_anchor_ver_angle(self): if hasattr(self, '_m_has_field_focus_anchor_ver_angle'): return self._m_has_field_focus_anchor_ver_angle self._m_has_field_focus_anchor_ver_angle = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_focus_anchor_ver_angle', None) class MusicGameParamComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClimateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementStateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_element_icon: self.element_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_element_type', None) @property def has_field_element_icon(self): if hasattr(self, '_m_has_field_element_icon'): return self._m_has_field_element_icon self._m_has_field_element_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_element_icon', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rank', None) class EnumMonsterSecurityLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonsterSecurityLevel, self.data.value) return getattr(self, '_m_value', None) class ConfigAttackEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attack_pattern: self.attack_pattern = Output.DispConfigBaseAttackPattern(self._io, self, self._root) if self.has_field_attack_info: self.attack_info = Output.ConfigAttackInfo(self._io, self, self._root) @property def has_field_attack_pattern(self): if hasattr(self, '_m_has_field_attack_pattern'): return self._m_has_field_attack_pattern self._m_has_field_attack_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_pattern', None) @property def has_field_attack_info(self): if hasattr(self, '_m_has_field_attack_info'): return self._m_has_field_attack_info self._m_has_field_attack_info = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attack_info', None) class EnumDecisionArchetype(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DecisionArchetype, self.data.value) return getattr(self, '_m_value', None) class ReliquaryPowerupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_powerup_multiple: self.powerup_multiple = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_powerup_multiple(self): if hasattr(self, '_m_has_field_powerup_multiple'): return self._m_has_field_powerup_multiple self._m_has_field_powerup_multiple = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_powerup_multiple', None) class ConfigIk(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_remote_move_ik: self.remote_move_ik = Output.ConfigBoolForPlatforms(self._io, self, self._root) if self.has_field_remote_climb_ik: self.remote_climb_ik = Output.ConfigBoolForPlatforms(self._io, self, self._root) @property def has_field_remote_move_ik(self): if hasattr(self, '_m_has_field_remote_move_ik'): return self._m_has_field_remote_move_ik self._m_has_field_remote_move_ik = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_remote_move_ik', None) @property def has_field_remote_climb_ik(self): if hasattr(self, '_m_has_field_remote_climb_ik'): return self._m_has_field_remote_climb_ik self._m_has_field_remote_climb_ik = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_remote_climb_ik', None) class EnumMonsterType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonsterType, self.data.value) return getattr(self, '_m_value', None) class ChessCardTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigResourceCollectionContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_audio_resource_list: self.audio_resource_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_video_resource_list: self.video_resource_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_audio_resource_list(self): if hasattr(self, '_m_has_field_audio_resource_list'): return self._m_has_field_audio_resource_list self._m_has_field_audio_resource_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_audio_resource_list', None) @property def has_field_video_resource_list(self): if hasattr(self, '_m_has_field_video_resource_list'): return self._m_has_field_video_resource_list self._m_has_field_video_resource_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_video_resource_list', None) class IndicatorConditionPlayerLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level', None) class TargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetStateAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_gadget_state: self.gadget_state = Output.EnumGadgetState(self._io, self, self._root) if self.has_field_predicate: self.predicate = Output.DispConfigGadgetPredicate(self._io, self, self._root) @property def has_field_gadget_state(self): if hasattr(self, '_m_has_field_gadget_state'): return self._m_has_field_gadget_state self._m_has_field_gadget_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_state', None) @property def has_field_predicate(self): if hasattr(self, '_m_has_field_predicate'): return self._m_has_field_predicate self._m_has_field_predicate = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_predicate', None) class ConfigRuleCullingEventNameContain(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pattern: self.pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_pattern(self): if hasattr(self, '_m_has_field_pattern'): return self._m_has_field_pattern self._m_has_field_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pattern', None) class ReactionTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DamageStatisticsMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_min_damage: self.is_min_damage = self._io.read_u1() if self.has_field_damage_element_type_key: self.damage_element_type_key = AuxTypes.String(self._io, self, self._root) if self.has_field_damage_amount_key: self.damage_amount_key = AuxTypes.String(self._io, self, self._root) if self.has_field_on_exit_actions: self.on_exit_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_exit_actions(self): if hasattr(self, '_m_has_field_on_exit_actions'): return self._m_has_field_on_exit_actions self._m_has_field_on_exit_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_exit_actions', None) @property def has_field_damage_amount_key(self): if hasattr(self, '_m_has_field_damage_amount_key'): return self._m_has_field_damage_amount_key self._m_has_field_damage_amount_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_damage_amount_key', None) @property def has_field_is_min_damage(self): if hasattr(self, '_m_has_field_is_min_damage'): return self._m_has_field_is_min_damage self._m_has_field_is_min_damage = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_min_damage', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_damage_element_type_key(self): if hasattr(self, '_m_has_field_damage_element_type_key'): return self._m_has_field_damage_element_type_key self._m_has_field_damage_element_type_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_damage_element_type_key', None) class EnumAnimalCodexType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimalCodexType, self.data.value) return getattr(self, '_m_value', None) class ByTargetSkillPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_compare_type: self.compare_type = Output.EnumRelationType(self._io, self, self._root) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_compare_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumRogueGadgetDirType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueGadgetDirType, self.data.value) return getattr(self, '_m_value', None) class ConfigBulletMoveAngleByVelocity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMoveAngle(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trace_lerp_coef: self.trace_lerp_coef = self._io.read_f4le() if self.has_field_is_smooth_rotation: self.is_smooth_rotation = self._io.read_u1() @property def has_field_trace_lerp_coef(self): if hasattr(self, '_m_has_field_trace_lerp_coef'): return self._m_has_field_trace_lerp_coef self._m_has_field_trace_lerp_coef = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trace_lerp_coef', None) @property def has_field_is_smooth_rotation(self): if hasattr(self, '_m_has_field_is_smooth_rotation'): return self._m_has_field_is_smooth_rotation self._m_has_field_is_smooth_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_smooth_rotation', None) class HandbookQuestGuideShowCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumOpActivityTrackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpActivityTrackType, self.data.value) return getattr(self, '_m_value', None) class EnumActionBtnType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionBtnType, self.data.value) return getattr(self, '_m_value', None) class ConfigPerfItemOverrideInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_requirement_array: self.requirement_array = Output.ArrayOfConfigGraphicsRequirementLengthU(self._io, self, self._root) if self.has_field_device_override_rule: self.device_override_rule = Output.EnumPerfOptionOverrideRule(self._io, self, self._root) if self.has_field_combine_override_rule: self.combine_override_rule = Output.EnumPerfOptionOverrideRule(self._io, self, self._root) @property def has_field_requirement_array(self): if hasattr(self, '_m_has_field_requirement_array'): return self._m_has_field_requirement_array self._m_has_field_requirement_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_requirement_array', None) @property def has_field_device_override_rule(self): if hasattr(self, '_m_has_field_device_override_rule'): return self._m_has_field_device_override_rule self._m_has_field_device_override_rule = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_device_override_rule', None) @property def has_field_combine_override_rule(self): if hasattr(self, '_m_has_field_combine_override_rule'): return self._m_has_field_combine_override_rule self._m_has_field_combine_override_rule = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_combine_override_rule', None) class ResetAiAttackTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SalvageStageDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalShakeOff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reduce_durability: self.reduce_durability = self._io.read_f4le() if self.has_field_interval: self.interval = self._io.read_f4le() if self.has_field_shake_life_time: self.shake_life_time = self._io.read_f4le() if self.has_field_shake_value: self.shake_value = self._io.read_f4le() if self.has_field_shake_period: self.shake_period = self._io.read_f4le() if self.has_field_shake_smooth_ratio: self.shake_smooth_ratio = self._io.read_f4le() if self.has_field_shake_along_angle: self.shake_along_angle = self._io.read_f4le() if self.has_field_shake_rot_angle: self.shake_rot_angle = self._io.read_f4le() if self.has_field_shake_noise_ratio: self.shake_noise_ratio = self._io.read_f4le() if self.has_field_shake_dir_ratio: self.shake_dir_ratio = self._io.read_f4le() if self.has_field_shake_z_ratio: self.shake_z_ratio = self._io.read_f4le() @property def has_field_shake_dir_ratio(self): if hasattr(self, '_m_has_field_shake_dir_ratio'): return self._m_has_field_shake_dir_ratio self._m_has_field_shake_dir_ratio = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_shake_dir_ratio', None) @property def has_field_interval(self): if hasattr(self, '_m_has_field_interval'): return self._m_has_field_interval self._m_has_field_interval = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_interval', None) @property def has_field_shake_along_angle(self): if hasattr(self, '_m_has_field_shake_along_angle'): return self._m_has_field_shake_along_angle self._m_has_field_shake_along_angle = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_shake_along_angle', None) @property def has_field_shake_value(self): if hasattr(self, '_m_has_field_shake_value'): return self._m_has_field_shake_value self._m_has_field_shake_value = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shake_value', None) @property def has_field_shake_noise_ratio(self): if hasattr(self, '_m_has_field_shake_noise_ratio'): return self._m_has_field_shake_noise_ratio self._m_has_field_shake_noise_ratio = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_shake_noise_ratio', None) @property def has_field_shake_period(self): if hasattr(self, '_m_has_field_shake_period'): return self._m_has_field_shake_period self._m_has_field_shake_period = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_shake_period', None) @property def has_field_shake_smooth_ratio(self): if hasattr(self, '_m_has_field_shake_smooth_ratio'): return self._m_has_field_shake_smooth_ratio self._m_has_field_shake_smooth_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_shake_smooth_ratio', None) @property def has_field_shake_life_time(self): if hasattr(self, '_m_has_field_shake_life_time'): return self._m_has_field_shake_life_time self._m_has_field_shake_life_time = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shake_life_time', None) @property def has_field_shake_z_ratio(self): if hasattr(self, '_m_has_field_shake_z_ratio'): return self._m_has_field_shake_z_ratio self._m_has_field_shake_z_ratio = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_shake_z_ratio', None) @property def has_field_reduce_durability(self): if hasattr(self, '_m_has_field_reduce_durability'): return self._m_has_field_reduce_durability self._m_has_field_reduce_durability = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_reduce_durability', None) @property def has_field_shake_rot_angle(self): if hasattr(self, '_m_has_field_shake_rot_angle'): return self._m_has_field_shake_rot_angle self._m_has_field_shake_rot_angle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_shake_rot_angle', None) class CustomLevelComponentTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_name: self.type_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_type_name(self): if hasattr(self, '_m_has_field_type_name'): return self._m_has_field_type_name self._m_has_field_type_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_name', None) class EnumSettingEntryDisplayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SettingEntryDisplayType, self.data.value) return getattr(self, '_m_value', None) class AttackAttenuationExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableRocketJump(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumRocketJumpType(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_extention: self.extention = Output.RocketJumpExt(self._io, self, self._root) if self.has_field_ui_effect: self.ui_effect = self._io.read_u1() @property def has_field_ui_effect(self): if hasattr(self, '_m_has_field_ui_effect'): return self._m_has_field_ui_effect self._m_has_field_ui_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ui_effect', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_extention(self): if hasattr(self, '_m_has_field_extention'): return self._m_has_field_extention self._m_has_field_extention = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_extention', None) class SmaaQualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TokenForceEnqueueReasonComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChannellerSlabCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChannellerSlabCondition, self.data.value) return getattr(self, '_m_value', None) class EnumAttackCostType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AttackCostType, self.data.value) return getattr(self, '_m_value', None) class FireEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_othereffect_patterns: self.othereffect_patterns = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_owned_by_level: self.owned_by_level = self._io.read_u1() if self.has_field_use_y: self.use_y = self._io.read_u1() if self.has_field_scale: self.scale = self._io.read_f4le() if self.has_field_effect_templete_id: self.effect_templete_id = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_set_self_as_effect_plugin_target: self.set_self_as_effect_plugin_target = self._io.read_u1() if self.has_field_use_remote_self_pos: self.use_remote_self_pos = self._io.read_u1() @property def has_field_use_y(self): if hasattr(self, '_m_has_field_use_y'): return self._m_has_field_use_y self._m_has_field_use_y = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_use_y', None) @property def has_field_othereffect_patterns(self): if hasattr(self, '_m_has_field_othereffect_patterns'): return self._m_has_field_othereffect_patterns self._m_has_field_othereffect_patterns = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_othereffect_patterns', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_use_remote_self_pos(self): if hasattr(self, '_m_has_field_use_remote_self_pos'): return self._m_has_field_use_remote_self_pos self._m_has_field_use_remote_self_pos = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_use_remote_self_pos', None) @property def has_field_effect_templete_id(self): if hasattr(self, '_m_has_field_effect_templete_id'): return self._m_has_field_effect_templete_id self._m_has_field_effect_templete_id = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_effect_templete_id', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_set_self_as_effect_plugin_target(self): if hasattr(self, '_m_has_field_set_self_as_effect_plugin_target'): return self._m_has_field_set_self_as_effect_plugin_target self._m_has_field_set_self_as_effect_plugin_target = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_set_self_as_effect_plugin_target', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_owned_by_level(self): if hasattr(self, '_m_has_field_owned_by_level'): return self._m_has_field_owned_by_level self._m_has_field_owned_by_level = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_owned_by_level', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_born', None) class MaterialExpireTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnvironmentWeightTypeLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnvironmentWeightType(self._io, self, self._root)) class ConfigHomeworldFurnitureLight(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_light_details: self.light_details = Output.ArrayOfConfigHomeworldFurnitureLightDetailLengthU(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_id', None) @property def has_field_light_details(self): if hasattr(self, '_m_has_field_light_details'): return self._m_has_field_light_details self._m_has_field_light_details = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_light_details', None) class ReunionPrivilegeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerRageSupportMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TriggerTypeSupportMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_damp_ratio: self.damp_ratio = self._io.read_f4le() if self.has_field_add_ratio: self.add_ratio = self._io.read_f4le() if self.has_field_max_value: self.max_value = self._io.read_f4le() if self.has_field_min_value: self.min_value = self._io.read_f4le() @property def has_field_add_ratio(self): if hasattr(self, '_m_has_field_add_ratio'): return self._m_has_field_add_ratio self._m_has_field_add_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_add_ratio', None) @property def radius(self): if hasattr(self, '_m_radius'): return self._m_radius self._m_radius = self.base.radius return getattr(self, '_m_radius', None) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_damp_ratio(self): if hasattr(self, '_m_has_field_damp_ratio'): return self._m_has_field_damp_ratio self._m_has_field_damp_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_damp_ratio', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_value', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigChangeTimeInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_time: self.to_time = self._io.read_f4le() if self.has_field_extra_day: self.extra_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_force: self.force = self._io.read_u1() if self.has_field_use_fade: self.use_fade = self._io.read_u1() if self.has_field_fade_speed: self.fade_speed = self._io.read_f4le() @property def has_field_to_time(self): if hasattr(self, '_m_has_field_to_time'): return self._m_has_field_to_time self._m_has_field_to_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_time', None) @property def has_field_extra_day(self): if hasattr(self, '_m_has_field_extra_day'): return self._m_has_field_extra_day self._m_has_field_extra_day = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_extra_day', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_fade_speed(self): if hasattr(self, '_m_has_field_fade_speed'): return self._m_has_field_fade_speed self._m_has_field_fade_speed = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_fade_speed', None) @property def has_field_use_fade(self): if hasattr(self, '_m_has_field_use_fade'): return self._m_has_field_use_fade self._m_has_field_use_fade = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_fade', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_force(self): if hasattr(self, '_m_has_field_force'): return self._m_has_field_force self._m_has_field_force = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_force', None) class IndicatorConditionKilled(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) class KvpOfDictEnumCoopTemperamentTypeCoopTemperament(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumCoopTemperamentType(self._io, self, self._root) self.value = Output.CoopTemperament(self._io, self, self._root) class EnumExhibitionDisplayCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionDisplayCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigAnimal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_has_ability: self.has_ability = self._io.read_u1() if self.has_field_tick_ability_element: self.tick_ability_element = self._io.read_u1() if self.has_field_simple_combat: self.simple_combat = self._io.read_u1() if self.has_field_has_character_renderering: self.has_character_renderering = self._io.read_u1() @property def has_field_has_ability(self): if hasattr(self, '_m_has_field_has_ability'): return self._m_has_field_has_ability self._m_has_field_has_ability = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_has_ability', None) @property def has_field_tick_ability_element(self): if hasattr(self, '_m_has_field_tick_ability_element'): return self._m_has_field_tick_ability_element self._m_has_field_tick_ability_element = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tick_ability_element', None) @property def has_field_simple_combat(self): if hasattr(self, '_m_has_field_simple_combat'): return self._m_has_field_simple_combat self._m_has_field_simple_combat = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_simple_combat', None) @property def has_field_has_character_renderering(self): if hasattr(self, '_m_has_field_has_character_renderering'): return self._m_has_field_has_character_renderering self._m_has_field_has_character_renderering = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_has_character_renderering', None) class RandTaskRewardConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_vec: self.drop_vec = Output.ArrayOfRandTaskDropConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_drop_vec(self): if hasattr(self, '_m_has_field_drop_vec'): return self._m_has_field_drop_vec self._m_has_field_drop_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_drop_vec', None) class RoguelikeRuneExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetUseAttachAbilityGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_group_name_second: self.ability_group_name_second = AuxTypes.String(self._io, self, self._root) if self.has_field_shared_cd_group: self.shared_cd_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_replace_skill_hint_list: self.replace_skill_hint_list = Output.ArrayOfEnumWidgetSkillReplaceTypeLengthU(self._io, self, self._root) if self.has_field_is_update_cd_after_ability_trigger: self.is_update_cd_after_ability_trigger = self._io.read_u1() if self.has_field_is_skip_take_off_ability_group_when_change_avatar: self.is_skip_take_off_ability_group_when_change_avatar = self._io.read_u1() @property def has_field_ability_group_name_second(self): if hasattr(self, '_m_has_field_ability_group_name_second'): return self._m_has_field_ability_group_name_second self._m_has_field_ability_group_name_second = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_group_name_second', None) @property def has_field_is_skip_take_off_ability_group_when_change_avatar(self): if hasattr(self, '_m_has_field_is_skip_take_off_ability_group_when_change_avatar'): return self._m_has_field_is_skip_take_off_ability_group_when_change_avatar self._m_has_field_is_skip_take_off_ability_group_when_change_avatar = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_is_skip_take_off_ability_group_when_change_avatar', None) @property def has_field_replace_skill_hint_list(self): if hasattr(self, '_m_has_field_replace_skill_hint_list'): return self._m_has_field_replace_skill_hint_list self._m_has_field_replace_skill_hint_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_replace_skill_hint_list', None) @property def has_field_shared_cd_group(self): if hasattr(self, '_m_has_field_shared_cd_group'): return self._m_has_field_shared_cd_group self._m_has_field_shared_cd_group = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_shared_cd_group', None) @property def has_field_is_update_cd_after_ability_trigger(self): if hasattr(self, '_m_has_field_is_update_cd_after_ability_trigger'): return self._m_has_field_is_update_cd_after_ability_trigger self._m_has_field_is_update_cd_after_ability_trigger = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_update_cd_after_ability_trigger', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class BoredCreateMonsterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_player_level: self.player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_config_vec: self.monster_config_vec = Output.ArrayOfBoredMonsterConfigLengthS(self._io, self, self._root) @property def has_field_player_level(self): if hasattr(self, '_m_has_field_player_level'): return self._m_has_field_player_level self._m_has_field_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_player_level', None) @property def has_field_monster_config_vec(self): if hasattr(self, '_m_has_field_monster_config_vec'): return self._m_has_field_monster_config_vec self._m_has_field_monster_config_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_config_vec', None) class TalkExecEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumTalkExecType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class SetOvergrowDamgeToOverrideMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_reaction_trigger_type: self.reaction_trigger_type = Output.EnumReactionTriggerType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_reaction_trigger_type(self): if hasattr(self, '_m_has_field_reaction_trigger_type'): return self._m_has_field_reaction_trigger_type self._m_has_field_reaction_trigger_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reaction_trigger_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class MichiaeBossChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_title: self.level_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_level_title(self): if hasattr(self, '_m_has_field_level_title'): return self._m_has_field_level_title self._m_has_field_level_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_title', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) class LogicTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestGuideLayerComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDitherByStartDitherAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) class ReunionCommercialExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRecoverEnergyEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_effects: self.effects = Output.ArrayOfConfigEffectWithThresholdLengthU(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effects', None) class BlessingScanTypeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_up_pool_id: self.up_pool_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_daily_scan_limit: self.daily_scan_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_name: self.type_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_name_with_color: self.type_name_with_color = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_type_name(self): if hasattr(self, '_m_has_field_type_name'): return self._m_has_field_type_name self._m_has_field_type_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_type_name', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_daily_scan_limit(self): if hasattr(self, '_m_has_field_daily_scan_limit'): return self._m_has_field_daily_scan_limit self._m_has_field_daily_scan_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_daily_scan_limit', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_up_pool_id(self): if hasattr(self, '_m_has_field_up_pool_id'): return self._m_has_field_up_pool_id self._m_has_field_up_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_up_pool_id', None) @property def has_field_type_name_with_color(self): if hasattr(self, '_m_has_field_type_name_with_color'): return self._m_has_field_type_name_with_color self._m_has_field_type_name_with_color = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_type_name_with_color', None) class EnumQuestSpecialShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestSpecialShowType, self.data.value) return getattr(self, '_m_value', None) class SectorBinData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSpawnAttachInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_remove: self.is_remove = self._io.read_u1() if self.has_field_attach_name: self.attach_name = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_is_remove(self): if hasattr(self, '_m_has_field_is_remove'): return self._m_has_field_is_remove self._m_has_field_is_remove = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_remove', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_attach_name(self): if hasattr(self, '_m_has_field_attach_name'): return self._m_has_field_attach_name self._m_has_field_attach_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_name', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class CoopSavePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_end: self.is_end = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_is_end(self): if hasattr(self, '_m_has_field_is_end'): return self._m_has_field_is_end self._m_has_field_is_end = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_end', None) class ArrayOfArrayOfF4LengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfF4LengthU(self._io, self, self._root)) class ActivityCrystalLinkLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_buff_id_list: self.cond_buff_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_effect_buff_id_list: self.effect_buff_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_title: self.level_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_config_array: self.monster_config_array = Output.ArrayOfMonsterConfigLengthS(self._io, self, self._root) if self.has_field_main_monster_config_array: self.main_monster_config_array = Output.ArrayOfMainMonsterConfigLengthS(self._io, self, self._root) if self.has_field_score_level_list: self.score_level_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_cd: self.cond_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_eff_last_time: self.eff_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cond_cd(self): if hasattr(self, '_m_has_field_cond_cd'): return self._m_has_field_cond_cd self._m_has_field_cond_cd = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_cond_cd', None) @property def has_field_eff_last_time(self): if hasattr(self, '_m_has_field_eff_last_time'): return self._m_has_field_eff_last_time self._m_has_field_eff_last_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_eff_last_time', None) @property def has_field_level_title(self): if hasattr(self, '_m_has_field_level_title'): return self._m_has_field_level_title self._m_has_field_level_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_level_title', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_effect_buff_id_list(self): if hasattr(self, '_m_has_field_effect_buff_id_list'): return self._m_has_field_effect_buff_id_list self._m_has_field_effect_buff_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_effect_buff_id_list', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_monster_config_array(self): if hasattr(self, '_m_has_field_monster_config_array'): return self._m_has_field_monster_config_array self._m_has_field_monster_config_array = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_monster_config_array', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_level_desc', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_cond_buff_id_list(self): if hasattr(self, '_m_has_field_cond_buff_id_list'): return self._m_has_field_cond_buff_id_list self._m_has_field_cond_buff_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cond_buff_id_list', None) @property def has_field_score_level_list(self): if hasattr(self, '_m_has_field_score_level_list'): return self._m_has_field_score_level_list self._m_has_field_score_level_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_score_level_list', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_main_monster_config_array(self): if hasattr(self, '_m_has_field_main_monster_config_array'): return self._m_has_field_main_monster_config_array self._m_has_field_main_monster_config_array = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_main_monster_config_array', None) class ArrayOfGadgetInteractCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.GadgetInteractCond(self._io, self, self._root)) class DictOfAuxTypesStringU1(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringU1(self._io, self, self._root)) class WorldAreaExploreEventConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NeuronMixinRemoveOperatorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExhibitionCardOrderType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionCardOrderType, self.data.value) return getattr(self, '_m_value', None) class DeductStamina(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_swim_check: self.swim_check = self._io.read_u1() @property def has_field_swim_check(self): if hasattr(self, '_m_has_field_swim_check'): return self._m_has_field_swim_check self._m_has_field_swim_check = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_swim_check', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumSceneBuildingType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneBuildingType, self.data.value) return getattr(self, '_m_value', None) class QuestExecEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumQuestExecType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class EmotionTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_style_id: self.free_style_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_bubble_name: self.bubble_name = AuxTypes.String(self._io, self, self._root) if self.has_field_emotion_path: self.emotion_path = AuxTypes.String(self._io, self, self._root) if self.has_field_protect_time: self.protect_time = self._io.read_f4le() @property def has_field_protect_time(self): if hasattr(self, '_m_has_field_protect_time'): return self._m_has_field_protect_time self._m_has_field_protect_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_protect_time', None) @property def has_field_free_style_id(self): if hasattr(self, '_m_has_field_free_style_id'): return self._m_has_field_free_style_id self._m_has_field_free_style_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_free_style_id', None) @property def has_field_bubble_name(self): if hasattr(self, '_m_has_field_bubble_name'): return self._m_has_field_bubble_name self._m_has_field_bubble_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_bubble_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_emotion_path(self): if hasattr(self, '_m_has_field_emotion_path'): return self._m_has_field_emotion_path self._m_has_field_emotion_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_emotion_path', None) class ConfigLookAtEyeCtrlInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_clear_all: self.clear_all = self._io.read_u1() if self.has_field_use_target_pos: self.use_target_pos = self._io.read_u1() if self.has_field_target_position: self.target_position = Output.Vector(self._io, self, self._root) if self.has_field_eye_rotate_vec_left: self.eye_rotate_vec_left = Output.Vector(self._io, self, self._root) if self.has_field_eye_rotate_vec_right: self.eye_rotate_vec_right = Output.Vector(self._io, self, self._root) if self.has_field_eye_scale_x: self.eye_scale_x = self._io.read_f4le() if self.has_field_eye_scale_z: self.eye_scale_z = self._io.read_f4le() if self.has_field_turn_time: self.turn_time = self._io.read_f4le() if self.has_field_target_npc_alias: self.target_npc_alias = AuxTypes.String(self._io, self, self._root) if self.has_field_target_point: self.target_point = AuxTypes.String(self._io, self, self._root) @property def has_field_target_position(self): if hasattr(self, '_m_has_field_target_position'): return self._m_has_field_target_position self._m_has_field_target_position = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_target_position', None) @property def has_field_target_point(self): if hasattr(self, '_m_has_field_target_point'): return self._m_has_field_target_point self._m_has_field_target_point = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_target_point', None) @property def has_field_eye_scale_x(self): if hasattr(self, '_m_has_field_eye_scale_x'): return self._m_has_field_eye_scale_x self._m_has_field_eye_scale_x = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_eye_scale_x', None) @property def has_field_clear_all(self): if hasattr(self, '_m_has_field_clear_all'): return self._m_has_field_clear_all self._m_has_field_clear_all = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_clear_all', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_eye_scale_z(self): if hasattr(self, '_m_has_field_eye_scale_z'): return self._m_has_field_eye_scale_z self._m_has_field_eye_scale_z = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_eye_scale_z', None) @property def has_field_eye_rotate_vec_right(self): if hasattr(self, '_m_has_field_eye_rotate_vec_right'): return self._m_has_field_eye_rotate_vec_right self._m_has_field_eye_rotate_vec_right = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_eye_rotate_vec_right', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_eye_rotate_vec_left(self): if hasattr(self, '_m_has_field_eye_rotate_vec_left'): return self._m_has_field_eye_rotate_vec_left self._m_has_field_eye_rotate_vec_left = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_eye_rotate_vec_left', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_use_target_pos(self): if hasattr(self, '_m_has_field_use_target_pos'): return self._m_has_field_use_target_pos self._m_has_field_use_target_pos = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_use_target_pos', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_turn_time(self): if hasattr(self, '_m_has_field_turn_time'): return self._m_has_field_turn_time self._m_has_field_turn_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_turn_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_target_npc_alias(self): if hasattr(self, '_m_has_field_target_npc_alias'): return self._m_has_field_target_npc_alias self._m_has_field_target_npc_alias = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_target_npc_alias', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class EnumQuestFishType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestFishType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigEquipReattachLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEquipReattach(self._io, self, self._root)) class ConfigAiFleeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFleeData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFleeData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class WeaponAwayFromHandState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_state: self.state = AuxTypes.String(self._io, self, self._root) if self.has_field_start_norm_time: self.start_norm_time = self._io.read_f4le() if self.has_field_end_norm_time: self.end_norm_time = self._io.read_f4le() if self.has_field_delay_appear_time: self.delay_appear_time = self._io.read_f4le() if self.has_field_dissolve_show_time: self.dissolve_show_time = self._io.read_f4le() if self.has_field_dissolve_hide_time: self.dissolve_hide_time = self._io.read_f4le() @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state', None) @property def has_field_start_norm_time(self): if hasattr(self, '_m_has_field_start_norm_time'): return self._m_has_field_start_norm_time self._m_has_field_start_norm_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_norm_time', None) @property def has_field_end_norm_time(self): if hasattr(self, '_m_has_field_end_norm_time'): return self._m_has_field_end_norm_time self._m_has_field_end_norm_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_end_norm_time', None) @property def has_field_delay_appear_time(self): if hasattr(self, '_m_has_field_delay_appear_time'): return self._m_has_field_delay_appear_time self._m_has_field_delay_appear_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_delay_appear_time', None) @property def has_field_dissolve_hide_time(self): if hasattr(self, '_m_has_field_dissolve_hide_time'): return self._m_has_field_dissolve_hide_time self._m_has_field_dissolve_hide_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_dissolve_hide_time', None) @property def has_field_dissolve_show_time(self): if hasattr(self, '_m_has_field_dissolve_show_time'): return self._m_has_field_dissolve_show_time self._m_has_field_dissolve_show_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_dissolve_show_time', None) class WorldAreaConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrLayerLoaderRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetTalkScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talks: self.talks = Output.ArrayOfConfigTalkSchemeLengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_talks(self): if hasattr(self, '_m_has_field_talks'): return self._m_has_field_talks self._m_has_field_talks = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_talks', None) class ConfigDither(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_show_dither_duration: self.show_dither_duration = self._io.read_f4le() if self.has_field_start_dither_action: self.start_dither_action = Output.ConfigDitherByStartDitherAction(self._io, self, self._root) if self.has_field_between_camera_and_avatar: self.between_camera_and_avatar = Output.ConfigDitherByBetweenCameraAndAvatar(self._io, self, self._root) if self.has_field_normal_between_camera: self.normal_between_camera = Output.ConfigDitherByNormalBetweenCamera(self._io, self, self._root) if self.has_field_hide_effect_when_dither: self.hide_effect_when_dither = self._io.read_u1() @property def has_field_hide_effect_when_dither(self): if hasattr(self, '_m_has_field_hide_effect_when_dither'): return self._m_has_field_hide_effect_when_dither self._m_has_field_hide_effect_when_dither = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_hide_effect_when_dither', None) @property def has_field_start_dither_action(self): if hasattr(self, '_m_has_field_start_dither_action'): return self._m_has_field_start_dither_action self._m_has_field_start_dither_action = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_dither_action', None) @property def has_field_normal_between_camera(self): if hasattr(self, '_m_has_field_normal_between_camera'): return self._m_has_field_normal_between_camera self._m_has_field_normal_between_camera = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_normal_between_camera', None) @property def has_field_show_dither_duration(self): if hasattr(self, '_m_has_field_show_dither_duration'): return self._m_has_field_show_dither_duration self._m_has_field_show_dither_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show_dither_duration', None) @property def has_field_between_camera_and_avatar(self): if hasattr(self, '_m_has_field_between_camera_and_avatar'): return self._m_has_field_between_camera_and_avatar self._m_has_field_between_camera_and_avatar = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_between_camera_and_avatar', None) class AudioUiEquip(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_equip_on_event: self.equip_on_event = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_equip_on_event(self): if hasattr(self, '_m_has_field_equip_on_event'): return self._m_has_field_equip_on_event self._m_has_field_equip_on_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip_on_event', None) class DispConfigBaseInputAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseInputAction(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCompoundInputAction(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class FeatureTagGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivitySaleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiMixinSetBool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bool_id: self.bool_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_bool_id(self): if hasattr(self, '_m_has_field_bool_id'): return self._m_has_field_bool_id self._m_has_field_bool_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bool_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class DirectionMask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_mask: self.mask = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_mask(self): if hasattr(self, '_m_has_field_mask'): return self._m_has_field_mask self._m_has_field_mask = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mask', None) class PlayModeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHomeWorldAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HomeWorldAreaType, self.data.value) return getattr(self, '_m_value', None) class ConfigBaseCutscene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumCutsceneType(self._io, self, self._root) if self.has_field_pre_task_cfg: self.pre_task_cfg = Output.ConfigCutscenePreTask(self._io, self, self._root) if self.has_field_can_skip: self.can_skip = self._io.read_u1() if self.has_field_force_can_skip: self.force_can_skip = self._io.read_u1() if self.has_field_skip_general_dialog: self.skip_general_dialog = self._io.read_u1() if self.has_field_can: self.can = self._io.read_u1() if self.has_field_clear_black_screen: self.clear_black_screen = self._io.read_u1() if self.has_field_fade_out_when_finish: self.fade_out_when_finish = self._io.read_f4le() if self.has_field_direct_transmit: self.direct_transmit = self._io.read_u1() if self.has_field_delay_transmit: self.delay_transmit = self._io.read_f4le() if self.has_field_lua_data_path: self.lua_data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_res_path: self.res_path = AuxTypes.String(self._io, self, self._root) if self.has_field_cast_list_path: self.cast_list_path = AuxTypes.String(self._io, self, self._root) if self.has_field_entity_ban: self.entity_ban = AuxTypes.String(self._io, self, self._root) if self.has_field_start_pos_type: self.start_pos_type = Output.EnumCutsceneInitPosType(self._io, self, self._root) if self.has_field_start_offset: self.start_offset = Output.Vector(self._io, self, self._root) if self.has_field_need_xz_euler: self.need_xz_euler = self._io.read_u1() if self.has_field_need_y_euler: self.need_y_euler = self._io.read_u1() if self.has_field_keep_camera: self.keep_camera = self._io.read_u1() if self.has_field_use_target_pos: self.use_target_pos = self._io.read_u1() if self.has_field_target_pos: self.target_pos = Output.Vector(self._io, self, self._root) if self.has_field_modify_last_pose_offset: self.modify_last_pose_offset = self._io.read_u1() if self.has_field_attack_mode_recover: self.attack_mode_recover = self._io.read_u1() if self.has_field_crowd_lod0list: self.crowd_lod0list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_enable_camera_displacement: self.enable_camera_displacement = self._io.read_u1() if self.has_field_entity_runtime_id: self.entity_runtime_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_clear_avatar_local_gadget: self.clear_avatar_local_gadget = self._io.read_u1() if self.has_field_disable_gpu_culling: self.disable_gpu_culling = self._io.read_u1() if self.has_field_can_player_loop: self.can_player_loop = self._io.read_u1() if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_disable_avatar_local_gadget: self.disable_avatar_local_gadget = self._io.read_u1() @property def has_field_modify_last_pose_offset(self): if hasattr(self, '_m_has_field_modify_last_pose_offset'): return self._m_has_field_modify_last_pose_offset self._m_has_field_modify_last_pose_offset = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_modify_last_pose_offset', None) @property def has_field_start_pos_type(self): if hasattr(self, '_m_has_field_start_pos_type'): return self._m_has_field_start_pos_type self._m_has_field_start_pos_type = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_start_pos_type', None) @property def has_field_disable_avatar_local_gadget(self): if hasattr(self, '_m_has_field_disable_avatar_local_gadget'): return self._m_has_field_disable_avatar_local_gadget self._m_has_field_disable_avatar_local_gadget = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_disable_avatar_local_gadget', None) @property def has_field_keep_camera(self): if hasattr(self, '_m_has_field_keep_camera'): return self._m_has_field_keep_camera self._m_has_field_keep_camera = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_keep_camera', None) @property def has_field_can_skip(self): if hasattr(self, '_m_has_field_can_skip'): return self._m_has_field_can_skip self._m_has_field_can_skip = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_can_skip', None) @property def has_field_can_player_loop(self): if hasattr(self, '_m_has_field_can_player_loop'): return self._m_has_field_can_player_loop self._m_has_field_can_player_loop = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_can_player_loop', None) @property def has_field_start_offset(self): if hasattr(self, '_m_has_field_start_offset'): return self._m_has_field_start_offset self._m_has_field_start_offset = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_start_offset', None) @property def has_field_lua_data_path(self): if hasattr(self, '_m_has_field_lua_data_path'): return self._m_has_field_lua_data_path self._m_has_field_lua_data_path = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_lua_data_path', None) @property def has_field_crowd_lod0list(self): if hasattr(self, '_m_has_field_crowd_lod0list'): return self._m_has_field_crowd_lod0list self._m_has_field_crowd_lod0list = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_crowd_lod0list', None) @property def has_field_clear_avatar_local_gadget(self): if hasattr(self, '_m_has_field_clear_avatar_local_gadget'): return self._m_has_field_clear_avatar_local_gadget self._m_has_field_clear_avatar_local_gadget = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_clear_avatar_local_gadget', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_force_can_skip(self): if hasattr(self, '_m_has_field_force_can_skip'): return self._m_has_field_force_can_skip self._m_has_field_force_can_skip = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_force_can_skip', None) @property def has_field_cast_list_path(self): if hasattr(self, '_m_has_field_cast_list_path'): return self._m_has_field_cast_list_path self._m_has_field_cast_list_path = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_cast_list_path', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_entity_runtime_id(self): if hasattr(self, '_m_has_field_entity_runtime_id'): return self._m_has_field_entity_runtime_id self._m_has_field_entity_runtime_id = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_entity_runtime_id', None) @property def has_field_enable_camera_displacement(self): if hasattr(self, '_m_has_field_enable_camera_displacement'): return self._m_has_field_enable_camera_displacement self._m_has_field_enable_camera_displacement = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_enable_camera_displacement', None) @property def has_field_pre_task_cfg(self): if hasattr(self, '_m_has_field_pre_task_cfg'): return self._m_has_field_pre_task_cfg self._m_has_field_pre_task_cfg = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_pre_task_cfg', None) @property def has_field_attack_mode_recover(self): if hasattr(self, '_m_has_field_attack_mode_recover'): return self._m_has_field_attack_mode_recover self._m_has_field_attack_mode_recover = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_attack_mode_recover', None) @property def has_field_use_target_pos(self): if hasattr(self, '_m_has_field_use_target_pos'): return self._m_has_field_use_target_pos self._m_has_field_use_target_pos = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_use_target_pos', None) @property def has_field_target_pos(self): if hasattr(self, '_m_has_field_target_pos'): return self._m_has_field_target_pos self._m_has_field_target_pos = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_target_pos', None) @property def has_field_can(self): if hasattr(self, '_m_has_field_can'): return self._m_has_field_can self._m_has_field_can = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_can', None) @property def has_field_skip_general_dialog(self): if hasattr(self, '_m_has_field_skip_general_dialog'): return self._m_has_field_skip_general_dialog self._m_has_field_skip_general_dialog = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_skip_general_dialog', None) @property def has_field_direct_transmit(self): if hasattr(self, '_m_has_field_direct_transmit'): return self._m_has_field_direct_transmit self._m_has_field_direct_transmit = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_direct_transmit', None) @property def has_field_res_path(self): if hasattr(self, '_m_has_field_res_path'): return self._m_has_field_res_path self._m_has_field_res_path = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_res_path', None) @property def has_field_need_xz_euler(self): if hasattr(self, '_m_has_field_need_xz_euler'): return self._m_has_field_need_xz_euler self._m_has_field_need_xz_euler = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_need_xz_euler', None) @property def has_field_need_y_euler(self): if hasattr(self, '_m_has_field_need_y_euler'): return self._m_has_field_need_y_euler self._m_has_field_need_y_euler = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_need_y_euler', None) @property def has_field_delay_transmit(self): if hasattr(self, '_m_has_field_delay_transmit'): return self._m_has_field_delay_transmit self._m_has_field_delay_transmit = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_delay_transmit', None) @property def has_field_entity_ban(self): if hasattr(self, '_m_has_field_entity_ban'): return self._m_has_field_entity_ban self._m_has_field_entity_ban = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_entity_ban', None) @property def has_field_fade_out_when_finish(self): if hasattr(self, '_m_has_field_fade_out_when_finish'): return self._m_has_field_fade_out_when_finish self._m_has_field_fade_out_when_finish = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_fade_out_when_finish', None) @property def has_field_clear_black_screen(self): if hasattr(self, '_m_has_field_clear_black_screen'): return self._m_has_field_clear_black_screen self._m_has_field_clear_black_screen = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_clear_black_screen', None) @property def has_field_disable_gpu_culling(self): if hasattr(self, '_m_has_field_disable_gpu_culling'): return self._m_has_field_disable_gpu_culling self._m_has_field_disable_gpu_culling = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_disable_gpu_culling', None) class ConfigAiBirdCirclingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiBirdCirclingData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiBirdCirclingData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class TowerBuffLastingTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BonusSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAttachmentData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attach_map: self.attach_map = Output.DictOfAuxTypesStringConfigAttachment(self._io, self, self._root) @property def has_field_attach_map(self): if hasattr(self, '_m_has_field_attach_map'): return self._m_has_field_attach_map self._m_has_field_attach_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_map', None) class ActivityCrystalLinkCondBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_title: self.ability_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_desc: self.ability_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_pre = self._io.read_s1() if self.has_field_des_param: self.des_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ability_desc(self): if hasattr(self, '_m_has_field_ability_desc'): return self._m_has_field_ability_desc self._m_has_field_ability_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_ability_desc', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_ability_title(self): if hasattr(self, '_m_has_field_ability_title'): return self._m_has_field_ability_title self._m_has_field_ability_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ability_title', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_buff_id', None) @property def has_field_icon_name_hash(self): if hasattr(self, '_m_has_field_icon_name_hash'): return self._m_has_field_icon_name_hash self._m_has_field_icon_name_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon_name_hash', None) @property def has_field_des_param(self): if hasattr(self, '_m_has_field_des_param'): return self._m_has_field_des_param self._m_has_field_des_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_des_param', None) class HideAndSeekSkillSubCategoryComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumElementReactionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ElementReactionType, self.data.value) return getattr(self, '_m_value', None) class FeatureTagExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tag_id: self.tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tag_id(self): if hasattr(self, '_m_has_field_tag_id'): return self._m_has_field_tag_id self._m_has_field_tag_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tag_id', None) class HomeWorldFarmFieldExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_points: self.cost_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect: self.effect = Output.IrodoriChessCardEffect(self._io, self, self._root) if self.has_field_extra_effect_list: self.extra_effect_list = Output.ArrayOfIrodoriChessCardEffectLengthS(self._io, self, self._root) if self.has_field_card_type: self.card_type = Output.EnumIrodoriChessCardType(self._io, self, self._root) if self.has_field_card_quality_type: self.card_quality_type = Output.EnumIrodoriChessCardQualityType(self._io, self, self._root) if self.has_field_tag: self.tag = Output.EnumIrodoriChessCardTag(self._io, self, self._root) if self.has_field_card_name: self.card_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param: self.desc_param = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_card_numerical_list: self.card_numerical_list = Output.ArrayOfIrodoriCardNumericalLengthS(self._io, self, self._root) @property def has_field_card_name(self): if hasattr(self, '_m_has_field_card_name'): return self._m_has_field_card_name self._m_has_field_card_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_card_name', None) @property def has_field_desc_param(self): if hasattr(self, '_m_has_field_desc_param'): return self._m_has_field_desc_param self._m_has_field_desc_param = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_desc_param', None) @property def has_field_card_numerical_list(self): if hasattr(self, '_m_has_field_card_numerical_list'): return self._m_has_field_card_numerical_list self._m_has_field_card_numerical_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_card_numerical_list', None) @property def has_field_cost_points(self): if hasattr(self, '_m_has_field_cost_points'): return self._m_has_field_cost_points self._m_has_field_cost_points = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cost_points', None) @property def has_field_effect(self): if hasattr(self, '_m_has_field_effect'): return self._m_has_field_effect self._m_has_field_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_effect', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_tag', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_card_type(self): if hasattr(self, '_m_has_field_card_type'): return self._m_has_field_card_type self._m_has_field_card_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_card_type', None) @property def has_field_extra_effect_list(self): if hasattr(self, '_m_has_field_extra_effect_list'): return self._m_has_field_extra_effect_list self._m_has_field_extra_effect_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_extra_effect_list', None) @property def has_field_card_quality_type(self): if hasattr(self, '_m_has_field_card_quality_type'): return self._m_has_field_card_quality_type self._m_has_field_card_quality_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_card_quality_type', None) class KvpOfDictAuxTypesStringArrayOfConfigElementDecrateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfConfigElementDecrateLengthU(self._io, self, self._root) class ConfigBoundary(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shape: self.shape = AuxTypes.String(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_euler: self.euler = Output.Vector(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_shape(self): if hasattr(self, '_m_has_field_shape'): return self._m_has_field_shape self._m_has_field_shape = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_shape', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_euler(self): if hasattr(self, '_m_has_field_euler'): return self._m_has_field_euler self._m_has_field_euler = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_euler', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_offset', None) class ConfigProgressBillboard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBillboard(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_custom_key_list: self.custom_key_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_max_value: self.max_value = self._io.read_f4le() if self.has_field_prefab_plugin_name: self.prefab_plugin_name = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumProgressBillboardType(self._io, self, self._root) if self.has_field_need_up_anim: self.need_up_anim = self._io.read_u1() @property def offset_type(self): if hasattr(self, '_m_offset_type'): return self._m_offset_type self._m_offset_type = self.base.offset_type return getattr(self, '_m_offset_type', None) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_prefab_plugin_name(self): if hasattr(self, '_m_has_field_prefab_plugin_name'): return self._m_has_field_prefab_plugin_name self._m_has_field_prefab_plugin_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_prefab_plugin_name', None) @property def show_distance(self): if hasattr(self, '_m_show_distance'): return self._m_show_distance self._m_show_distance = self.base.show_distance return getattr(self, '_m_show_distance', None) @property def radius_offset(self): if hasattr(self, '_m_radius_offset'): return self._m_radius_offset self._m_radius_offset = self.base.radius_offset return getattr(self, '_m_radius_offset', None) @property def name_show_distance(self): if hasattr(self, '_m_name_show_distance'): return self._m_name_show_distance self._m_name_show_distance = self.base.name_show_distance return getattr(self, '_m_name_show_distance', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_custom_key_list(self): if hasattr(self, '_m_has_field_custom_key_list'): return self._m_has_field_custom_key_list self._m_has_field_custom_key_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_key_list', None) @property def enable_self_adapt(self): if hasattr(self, '_m_enable_self_adapt'): return self._m_enable_self_adapt self._m_enable_self_adapt = self.base.enable_self_adapt return getattr(self, '_m_enable_self_adapt', None) @property def mark_show_distance(self): if hasattr(self, '_m_mark_show_distance'): return self._m_mark_show_distance self._m_mark_show_distance = self.base.mark_show_distance return getattr(self, '_m_mark_show_distance', None) @property def attach_point(self): if hasattr(self, '_m_attach_point'): return self._m_attach_point self._m_attach_point = self.base.attach_point return getattr(self, '_m_attach_point', None) @property def force_hide_all_bars(self): if hasattr(self, '_m_force_hide_all_bars'): return self._m_force_hide_all_bars self._m_force_hide_all_bars = self.base.force_hide_all_bars return getattr(self, '_m_force_hide_all_bars', None) @property def has_field_need_up_anim(self): if hasattr(self, '_m_has_field_need_up_anim'): return self._m_has_field_need_up_anim self._m_has_field_need_up_anim = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_need_up_anim', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigBeHitEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity: self.entity = Output.EntityBeHitEffect(self._io, self, self._root) if self.has_field_scene: self.scene = Output.SceneBeHitEffect(self._io, self, self._root) @property def has_field_entity(self): if hasattr(self, '_m_has_field_entity'): return self._m_has_field_entity self._m_has_field_entity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity', None) @property def has_field_scene(self): if hasattr(self, '_m_has_field_scene'): return self._m_has_field_scene self._m_has_field_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scene', None) class CityTaskOpenExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByIsGadgetExistAround(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id_array: self.gadget_id_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_trun_to_target: self.trun_to_target = self._io.read_u1() @property def has_field_gadget_id_array(self): if hasattr(self, '_m_has_field_gadget_id_array'): return self._m_has_field_gadget_id_array self._m_has_field_gadget_id_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id_array', None) @property def has_field_trun_to_target(self): if hasattr(self, '_m_has_field_trun_to_target'): return self._m_has_field_trun_to_target self._m_has_field_trun_to_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trun_to_target', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class NewActivityTimeGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ItemLimitConstValueTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hit_data: self.hit_data = Output.ConfigGlobalHit(self._io, self, self._root) if self.has_field_collision_data: self.collision_data = Output.ConfigGlobalCollision(self._io, self, self._root) if self.has_field_ai_data: self.ai_data = Output.ConfigGlobalAi(self._io, self, self._root) if self.has_field_move_data: self.move_data = Output.ConfigGlobalMove(self._io, self, self._root) if self.has_field_default_avatar_hit_bucket_setting: self.default_avatar_hit_bucket_setting = Output.ConfigAvatarHitBucketSetting(self._io, self, self._root) if self.has_field_element_blade_data: self.element_blade_data = Output.DictOfAuxTypesStringConfigBladeElementFx(self._io, self, self._root) if self.has_field_fire_grass_airflow_data: self.fire_grass_airflow_data = Output.ConfigFireGrassAirflowField(self._io, self, self._root) if self.has_field_miscs: self.miscs = Output.ConfigGloablMiscs(self._io, self, self._root) if self.has_field_default_abilities: self.default_abilities = Output.ConfigDefaultAbilities(self._io, self, self._root) if self.has_field_elem_react_damage: self.elem_react_damage = Output.DictOfAuxTypesStringDictOfAuxTypesStringF4(self._io, self, self._root) if self.has_field_elem_amplify_damage: self.elem_amplify_damage = Output.DictOfAuxTypesStringDictOfAuxTypesStringF4(self._io, self, self._root) if self.has_field_elem_prority: self.elem_prority = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_shake_off: self.shake_off = Output.ConfigGlobalShakeOff(self._io, self, self._root) if self.has_field_element_shield: self.element_shield = Output.ConfigElementShield(self._io, self, self._root) if self.has_field_elite_shield: self.elite_shield = Output.ConfigEliteShield(self._io, self, self._root) if self.has_field_global_switch: self.global_switch = Output.ConfigGlobalSwitch(self._io, self, self._root) if self.has_field_lock_target: self.lock_target = Output.ConfigGlobalLockTarget(self._io, self, self._root) if self.has_field_elem_ui: self.elem_ui = Output.ConfigElementUi(self._io, self, self._root) if self.has_field_reject_element_reaction: self.reject_element_reaction = Output.DictOfEnumAbilityStateArrayOfEnumElementReactionTypeLengthU(self._io, self, self._root) if self.has_field_log_setting: self.log_setting = Output.ConfigLogSetting(self._io, self, self._root) if self.has_field_attack_attenuation: self.attack_attenuation = Output.DictOfAuxTypesStringConfigAttackAttenuation(self._io, self, self._root) if self.has_field_gadget_creation_limits: self.gadget_creation_limits = Output.ArrayOfConfigGadgetCreationLimitLengthU(self._io, self, self._root) if self.has_field_lua_safety_switch: self.lua_safety_switch = Output.ConfigLuaSafetyCheckSwitch(self._io, self, self._root) if self.has_field_temp_component_budget: self.temp_component_budget = Output.DictOfAuxTypesVlqBase128LeSF4(self._io, self, self._root) if self.has_field_global_interaction: self.global_interaction = Output.ConfigGlobalInteraction(self._io, self, self._root) if self.has_field_lamp_offset: self.lamp_offset = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_ability_state_trigger_abilities: self.ability_state_trigger_abilities = Output.DictOfEnumAbilityStateAuxTypesString(self._io, self, self._root) if self.has_field_dither: self.dither = Output.ConfigGlobalDither(self._io, self, self._root) if self.has_field_element_decrate_group: self.element_decrate_group = Output.DictOfAuxTypesStringArrayOfConfigElementDecrateLengthU(self._io, self, self._root) if self.has_field_slice_frame_watch: self.slice_frame_watch = Output.ConfigSliceFrameWatch(self._io, self, self._root) if self.has_field_ik: self.ik = Output.ConfigIk(self._io, self, self._root) if self.has_field_avatar_equip_size_datas: self.avatar_equip_size_datas = Output.DictOfAuxTypesVlqBase128LeSArrayOfEquipSizeDataLengthU(self._io, self, self._root) if self.has_field_manekin_equip_size_datas: self.manekin_equip_size_datas = Output.DictOfAuxTypesVlqBase128LeSArrayOfEquipSizeDataLengthU(self._io, self, self._root) if self.has_field_big_world_environment_damage_clamp: self.big_world_environment_damage_clamp = Output.ConfigBigWorldEnvironmentDamageClamp(self._io, self, self._root) if self.has_field_td_play: self.td_play = Output.ConfigTdPlay(self._io, self, self._root) if self.has_field_game_anim_safe_type: self.game_anim_safe_type = Output.ConfigSafeTypeReportData(self._io, self, self._root) if self.has_field_element_convert_to_charge_bar_value_mixin_item_group: self.element_convert_to_charge_bar_value_mixin_item_group = Output.DictOfAuxTypesStringArrayOfElementConvertToChargeBarValueMixinItemLengthU(self._io, self, self._root) if self.has_field_charge_bar_mixin_global_value_key: self.charge_bar_mixin_global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_element_reaction_coefficients: self.element_reaction_coefficients = Output.ConfigElementReactionCoefficients(self._io, self, self._root) if self.has_field_battle_fervor_formula: self.battle_fervor_formula = Output.ConfigBattleFervorFormula(self._io, self, self._root) if self.has_field_combat_template: self.combat_template = Output.DictOfAuxTypesStringConfigCombat(self._io, self, self._root) if self.has_field_combat_anti_cheat_attack_tag_white_list: self.combat_anti_cheat_attack_tag_white_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_bddnmfnmlan: self.bddnmfnmlan = Output.Olfcladmpah(self._io, self, self._root) @property def has_field_global_interaction(self): if hasattr(self, '_m_has_field_global_interaction'): return self._m_has_field_global_interaction self._m_has_field_global_interaction = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_global_interaction', None) @property def has_field_lock_target(self): if hasattr(self, '_m_has_field_lock_target'): return self._m_has_field_lock_target self._m_has_field_lock_target = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_lock_target', None) @property def has_field_combat_template(self): if hasattr(self, '_m_has_field_combat_template'): return self._m_has_field_combat_template self._m_has_field_combat_template = (self.bit_field.value & 1099511627776) != 0 return getattr(self, '_m_has_field_combat_template', None) @property def has_field_lamp_offset(self): if hasattr(self, '_m_has_field_lamp_offset'): return self._m_has_field_lamp_offset self._m_has_field_lamp_offset = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_lamp_offset', None) @property def has_field_charge_bar_mixin_global_value_key(self): if hasattr(self, '_m_has_field_charge_bar_mixin_global_value_key'): return self._m_has_field_charge_bar_mixin_global_value_key self._m_has_field_charge_bar_mixin_global_value_key = (self.bit_field.value & 137438953472) != 0 return getattr(self, '_m_has_field_charge_bar_mixin_global_value_key', None) @property def has_field_ability_state_trigger_abilities(self): if hasattr(self, '_m_has_field_ability_state_trigger_abilities'): return self._m_has_field_ability_state_trigger_abilities self._m_has_field_ability_state_trigger_abilities = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_ability_state_trigger_abilities', None) @property def has_field_default_abilities(self): if hasattr(self, '_m_has_field_default_abilities'): return self._m_has_field_default_abilities self._m_has_field_default_abilities = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_default_abilities', None) @property def has_field_big_world_environment_damage_clamp(self): if hasattr(self, '_m_has_field_big_world_environment_damage_clamp'): return self._m_has_field_big_world_environment_damage_clamp self._m_has_field_big_world_environment_damage_clamp = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_big_world_environment_damage_clamp', None) @property def has_field_elem_react_damage(self): if hasattr(self, '_m_has_field_elem_react_damage'): return self._m_has_field_elem_react_damage self._m_has_field_elem_react_damage = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_elem_react_damage', None) @property def has_field_collision_data(self): if hasattr(self, '_m_has_field_collision_data'): return self._m_has_field_collision_data self._m_has_field_collision_data = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_collision_data', None) @property def has_field_attack_attenuation(self): if hasattr(self, '_m_has_field_attack_attenuation'): return self._m_has_field_attack_attenuation self._m_has_field_attack_attenuation = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_attack_attenuation', None) @property def has_field_element_blade_data(self): if hasattr(self, '_m_has_field_element_blade_data'): return self._m_has_field_element_blade_data self._m_has_field_element_blade_data = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_element_blade_data', None) @property def has_field_ai_data(self): if hasattr(self, '_m_has_field_ai_data'): return self._m_has_field_ai_data self._m_has_field_ai_data = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_ai_data', None) @property def has_field_combat_anti_cheat_attack_tag_white_list(self): if hasattr(self, '_m_has_field_combat_anti_cheat_attack_tag_white_list'): return self._m_has_field_combat_anti_cheat_attack_tag_white_list self._m_has_field_combat_anti_cheat_attack_tag_white_list = (self.bit_field.value & 2199023255552) != 0 return getattr(self, '_m_has_field_combat_anti_cheat_attack_tag_white_list', None) @property def has_field_element_convert_to_charge_bar_value_mixin_item_group(self): if hasattr(self, '_m_has_field_element_convert_to_charge_bar_value_mixin_item_group'): return self._m_has_field_element_convert_to_charge_bar_value_mixin_item_group self._m_has_field_element_convert_to_charge_bar_value_mixin_item_group = (self.bit_field.value & 68719476736) != 0 return getattr(self, '_m_has_field_element_convert_to_charge_bar_value_mixin_item_group', None) @property def has_field_bddnmfnmlan(self): if hasattr(self, '_m_has_field_bddnmfnmlan'): return self._m_has_field_bddnmfnmlan self._m_has_field_bddnmfnmlan = (self.bit_field.value & 4398046511104) != 0 return getattr(self, '_m_has_field_bddnmfnmlan', None) @property def has_field_manekin_equip_size_datas(self): if hasattr(self, '_m_has_field_manekin_equip_size_datas'): return self._m_has_field_manekin_equip_size_datas self._m_has_field_manekin_equip_size_datas = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_manekin_equip_size_datas', None) @property def has_field_elite_shield(self): if hasattr(self, '_m_has_field_elite_shield'): return self._m_has_field_elite_shield self._m_has_field_elite_shield = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_elite_shield', None) @property def has_field_avatar_equip_size_datas(self): if hasattr(self, '_m_has_field_avatar_equip_size_datas'): return self._m_has_field_avatar_equip_size_datas self._m_has_field_avatar_equip_size_datas = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_avatar_equip_size_datas', None) @property def has_field_elem_amplify_damage(self): if hasattr(self, '_m_has_field_elem_amplify_damage'): return self._m_has_field_elem_amplify_damage self._m_has_field_elem_amplify_damage = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_elem_amplify_damage', None) @property def has_field_miscs(self): if hasattr(self, '_m_has_field_miscs'): return self._m_has_field_miscs self._m_has_field_miscs = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_miscs', None) @property def has_field_element_reaction_coefficients(self): if hasattr(self, '_m_has_field_element_reaction_coefficients'): return self._m_has_field_element_reaction_coefficients self._m_has_field_element_reaction_coefficients = (self.bit_field.value & 274877906944) != 0 return getattr(self, '_m_has_field_element_reaction_coefficients', None) @property def has_field_global_switch(self): if hasattr(self, '_m_has_field_global_switch'): return self._m_has_field_global_switch self._m_has_field_global_switch = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_global_switch', None) @property def has_field_td_play(self): if hasattr(self, '_m_has_field_td_play'): return self._m_has_field_td_play self._m_has_field_td_play = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_td_play', None) @property def has_field_temp_component_budget(self): if hasattr(self, '_m_has_field_temp_component_budget'): return self._m_has_field_temp_component_budget self._m_has_field_temp_component_budget = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_temp_component_budget', None) @property def has_field_fire_grass_airflow_data(self): if hasattr(self, '_m_has_field_fire_grass_airflow_data'): return self._m_has_field_fire_grass_airflow_data self._m_has_field_fire_grass_airflow_data = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_fire_grass_airflow_data', None) @property def has_field_reject_element_reaction(self): if hasattr(self, '_m_has_field_reject_element_reaction'): return self._m_has_field_reject_element_reaction self._m_has_field_reject_element_reaction = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_reject_element_reaction', None) @property def has_field_log_setting(self): if hasattr(self, '_m_has_field_log_setting'): return self._m_has_field_log_setting self._m_has_field_log_setting = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_log_setting', None) @property def has_field_move_data(self): if hasattr(self, '_m_has_field_move_data'): return self._m_has_field_move_data self._m_has_field_move_data = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_move_data', None) @property def has_field_element_shield(self): if hasattr(self, '_m_has_field_element_shield'): return self._m_has_field_element_shield self._m_has_field_element_shield = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_element_shield', None) @property def has_field_default_avatar_hit_bucket_setting(self): if hasattr(self, '_m_has_field_default_avatar_hit_bucket_setting'): return self._m_has_field_default_avatar_hit_bucket_setting self._m_has_field_default_avatar_hit_bucket_setting = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_default_avatar_hit_bucket_setting', None) @property def has_field_battle_fervor_formula(self): if hasattr(self, '_m_has_field_battle_fervor_formula'): return self._m_has_field_battle_fervor_formula self._m_has_field_battle_fervor_formula = (self.bit_field.value & 549755813888) != 0 return getattr(self, '_m_has_field_battle_fervor_formula', None) @property def has_field_ik(self): if hasattr(self, '_m_has_field_ik'): return self._m_has_field_ik self._m_has_field_ik = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_ik', None) @property def has_field_slice_frame_watch(self): if hasattr(self, '_m_has_field_slice_frame_watch'): return self._m_has_field_slice_frame_watch self._m_has_field_slice_frame_watch = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_slice_frame_watch', None) @property def has_field_element_decrate_group(self): if hasattr(self, '_m_has_field_element_decrate_group'): return self._m_has_field_element_decrate_group self._m_has_field_element_decrate_group = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_element_decrate_group', None) @property def has_field_shake_off(self): if hasattr(self, '_m_has_field_shake_off'): return self._m_has_field_shake_off self._m_has_field_shake_off = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_shake_off', None) @property def has_field_gadget_creation_limits(self): if hasattr(self, '_m_has_field_gadget_creation_limits'): return self._m_has_field_gadget_creation_limits self._m_has_field_gadget_creation_limits = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_gadget_creation_limits', None) @property def has_field_elem_ui(self): if hasattr(self, '_m_has_field_elem_ui'): return self._m_has_field_elem_ui self._m_has_field_elem_ui = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_elem_ui', None) @property def has_field_dither(self): if hasattr(self, '_m_has_field_dither'): return self._m_has_field_dither self._m_has_field_dither = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_dither', None) @property def has_field_elem_prority(self): if hasattr(self, '_m_has_field_elem_prority'): return self._m_has_field_elem_prority self._m_has_field_elem_prority = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_elem_prority', None) @property def has_field_hit_data(self): if hasattr(self, '_m_has_field_hit_data'): return self._m_has_field_hit_data self._m_has_field_hit_data = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_hit_data', None) @property def has_field_game_anim_safe_type(self): if hasattr(self, '_m_has_field_game_anim_safe_type'): return self._m_has_field_game_anim_safe_type self._m_has_field_game_anim_safe_type = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_game_anim_safe_type', None) @property def has_field_lua_safety_switch(self): if hasattr(self, '_m_has_field_lua_safety_switch'): return self._m_has_field_lua_safety_switch self._m_has_field_lua_safety_switch = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_lua_safety_switch', None) class UgcTimeControlMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class RushMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_min_range: self.min_range = self._io.read_f4le() if self.has_field_max_range: self.max_range = self._io.read_f4le() if self.has_field_time_range: self.time_range = self._io.read_f4le() @property def has_field_time_range(self): if hasattr(self, '_m_has_field_time_range'): return self._m_has_field_time_range self._m_has_field_time_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_time_range', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_max_range(self): if hasattr(self, '_m_has_field_max_range'): return self._m_has_field_max_range self._m_has_field_max_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_range', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_min_range(self): if hasattr(self, '_m_has_field_min_range'): return self._m_has_field_min_range self._m_has_field_min_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_range', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_pos', None) class ConfigCoopSelectNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCoopBaseNode(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_select_list: self.select_list = Output.ArrayOfCoopSelectNodeContentLengthU(self._io, self, self._root) if self.has_field_delay_move_next: self.delay_move_next = self._io.read_u1() @property def next_node_array(self): if hasattr(self, '_m_next_node_array'): return self._m_next_node_array self._m_next_node_array = self.base.next_node_array return getattr(self, '_m_next_node_array', None) @property def coop_node_id(self): if hasattr(self, '_m_coop_node_id'): return self._m_coop_node_id self._m_coop_node_id = self.base.coop_node_id return getattr(self, '_m_coop_node_id', None) @property def has_field_select_list(self): if hasattr(self, '_m_has_field_select_list'): return self._m_has_field_select_list self._m_has_field_select_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_select_list', None) @property def coop_node_type(self): if hasattr(self, '_m_coop_node_type'): return self._m_coop_node_type self._m_coop_node_type = self.base.coop_node_type return getattr(self, '_m_coop_node_type', None) @property def has_field_delay_move_next(self): if hasattr(self, '_m_has_field_delay_move_next'): return self._m_has_field_delay_move_next self._m_has_field_delay_move_next = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_delay_move_next', None) class EnumWatcherTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WatcherTriggerType, self.data.value) return getattr(self, '_m_value', None) class EnumGuideOpenStateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideOpenStateType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideHomeSceneCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_in_home_big_world: self.is_in_home_big_world = self._io.read_u1() if self.has_field_is_in_home_room: self.is_in_home_room = self._io.read_u1() @property def has_field_is_in_home_big_world(self): if hasattr(self, '_m_has_field_is_in_home_big_world'): return self._m_has_field_is_in_home_big_world self._m_has_field_is_in_home_big_world = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_in_home_big_world', None) @property def has_field_is_in_home_room(self): if hasattr(self, '_m_has_field_is_in_home_room'): return self._m_has_field_is_in_home_room self._m_has_field_is_in_home_room = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_in_home_room', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumTemplateReminderStyleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TemplateReminderStyleType, self.data.value) return getattr(self, '_m_value', None) class EnumPerfOptionOverrideRule(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfOptionOverrideRule, self.data.value) return getattr(self, '_m_value', None) class ConfigQteStepCutsceneFailedBlackScreenAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_restart_save_point_id: self.restart_save_point_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_failed_sub_quest_id: self.failed_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_textmap_id: self.textmap_id = AuxTypes.String(self._io, self, self._root) if self.has_field_show_immediately: self.show_immediately = self._io.read_u1() @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def has_field_textmap_id(self): if hasattr(self, '_m_has_field_textmap_id'): return self._m_has_field_textmap_id self._m_has_field_textmap_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_textmap_id', None) @property def has_field_failed_sub_quest_id(self): if hasattr(self, '_m_has_field_failed_sub_quest_id'): return self._m_has_field_failed_sub_quest_id self._m_has_field_failed_sub_quest_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_failed_sub_quest_id', None) @property def has_field_show_immediately(self): if hasattr(self, '_m_has_field_show_immediately'): return self._m_has_field_show_immediately self._m_has_field_show_immediately = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_show_immediately', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_restart_save_point_id(self): if hasattr(self, '_m_has_field_restart_save_point_id'): return self._m_has_field_restart_save_point_id self._m_has_field_restart_save_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_restart_save_point_id', None) class ConfigMassiveElementTriggerAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_type: self.trigger_type = Output.EnumMassiveElementTriggerType(self._io, self, self._root) if self.has_field_stack_type: self.stack_type = Output.EnumModifierStacking(self._io, self, self._root) if self.has_field_reduce_durability: self.reduce_durability = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_attack_id: self.attack_id = AuxTypes.String(self._io, self, self._root) if self.has_field_action_id: self.action_id = AuxTypes.String(self._io, self, self._root) if self.has_field_on_flush: self.on_flush = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_pre_update: self.on_pre_update = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_detach: self.on_detach = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_trigger_type(self): if hasattr(self, '_m_has_field_trigger_type'): return self._m_has_field_trigger_type self._m_has_field_trigger_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_trigger_type', None) @property def has_field_on_pre_update(self): if hasattr(self, '_m_has_field_on_pre_update'): return self._m_has_field_on_pre_update self._m_has_field_on_pre_update = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_pre_update', None) @property def has_field_action_id(self): if hasattr(self, '_m_has_field_action_id'): return self._m_has_field_action_id self._m_has_field_action_id = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_action_id', None) @property def has_field_attack_id(self): if hasattr(self, '_m_has_field_attack_id'): return self._m_has_field_attack_id self._m_has_field_attack_id = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_attack_id', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_reduce_durability(self): if hasattr(self, '_m_has_field_reduce_durability'): return self._m_has_field_reduce_durability self._m_has_field_reduce_durability = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_reduce_durability', None) @property def has_field_stack_type(self): if hasattr(self, '_m_has_field_stack_type'): return self._m_has_field_stack_type self._m_has_field_stack_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_stack_type', None) @property def has_field_on_flush(self): if hasattr(self, '_m_has_field_on_flush'): return self._m_has_field_on_flush self._m_has_field_on_flush = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_flush', None) @property def has_field_on_detach(self): if hasattr(self, '_m_has_field_on_detach'): return self._m_has_field_on_detach self._m_has_field_on_detach = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_on_detach', None) class DispConfigAiThreatScoreBaseSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigAiThreatScoreBaseSetting(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigAitsAbilityGlobalValueSetting(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigAitsTargetBearingSetting(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigAitsTargetDistanceSetting(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigBornByElementPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ArrayOfLevelGadgetLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.LevelGadget(self._io, self, self._root)) class ConfigJudgeAvatarElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class ByteIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HuntingMonsterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OfferingOpenStateConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_offering_id: self.offering_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_state: self.open_state = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_item_limit: self.item_limit = Output.EnumItemLimitType(self._io, self, self._root) if self.has_field_is_continuous_level_up: self.is_continuous_level_up = self._io.read_u1() if self.has_field_max_level_limit_type: self.max_level_limit_type = Output.EnumOfferingMaxLevelLimitType(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_allow_host_in_mp_mode: self.is_allow_host_in_mp_mode = self._io.read_u1() @property def has_field_is_allow_host_in_mp_mode(self): if hasattr(self, '_m_has_field_is_allow_host_in_mp_mode'): return self._m_has_field_is_allow_host_in_mp_mode self._m_has_field_is_allow_host_in_mp_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_allow_host_in_mp_mode', None) @property def has_field_offering_id(self): if hasattr(self, '_m_has_field_offering_id'): return self._m_has_field_offering_id self._m_has_field_offering_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_offering_id', None) @property def has_field_item_limit(self): if hasattr(self, '_m_has_field_item_limit'): return self._m_has_field_item_limit self._m_has_field_item_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_limit', None) @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_state', None) @property def has_field_is_continuous_level_up(self): if hasattr(self, '_m_has_field_is_continuous_level_up'): return self._m_has_field_is_continuous_level_up self._m_has_field_is_continuous_level_up = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_continuous_level_up', None) @property def has_field_max_level_limit_type(self): if hasattr(self, '_m_has_field_max_level_limit_type'): return self._m_has_field_max_level_limit_type self._m_has_field_max_level_limit_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_level_limit_type', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_activity_id', None) class ConfigHomeworldSuiteNpcSpawnPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rotation', None) class StackMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfLevelTagGroupLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.LevelTagGroup(self._io, self, self._root)) class BinaryClipInfoComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAudioPlatformMoveSettingsUsagePairLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioPlatformMoveSettingsUsagePair(self._io, self, self._root)) class ConfigPaimon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_follow_off_set: self.follow_off_set = Output.Vector(self._io, self, self._root) if self.has_field_slow_down_range_xz: self.slow_down_range_xz = self._io.read_f4le() if self.has_field_slow_down_range_y: self.slow_down_range_y = self._io.read_f4le() if self.has_field_show_random_cd_min: self.show_random_cd_min = self._io.read_f4le() if self.has_field_show_random_cd_max: self.show_random_cd_max = self._io.read_f4le() @property def has_field_show_random_cd_min(self): if hasattr(self, '_m_has_field_show_random_cd_min'): return self._m_has_field_show_random_cd_min self._m_has_field_show_random_cd_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_show_random_cd_min', None) @property def has_field_follow_off_set(self): if hasattr(self, '_m_has_field_follow_off_set'): return self._m_has_field_follow_off_set self._m_has_field_follow_off_set = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_follow_off_set', None) @property def has_field_show_random_cd_max(self): if hasattr(self, '_m_has_field_show_random_cd_max'): return self._m_has_field_show_random_cd_max self._m_has_field_show_random_cd_max = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_show_random_cd_max', None) @property def has_field_slow_down_range_y(self): if hasattr(self, '_m_has_field_slow_down_range_y'): return self._m_has_field_slow_down_range_y self._m_has_field_slow_down_range_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_slow_down_range_y', None) @property def has_field_slow_down_range_xz(self): if hasattr(self, '_m_has_field_slow_down_range_xz'): return self._m_has_field_slow_down_range_xz self._m_has_field_slow_down_range_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_slow_down_range_xz', None) class HomeWorldFieldTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RouteTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicConjunctiveCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicBinaryCondition(self._io, self, self._root) @property def lhs_id(self): if hasattr(self, '_m_lhs_id'): return self._m_lhs_id self._m_lhs_id = self.base.lhs_id return getattr(self, '_m_lhs_id', None) @property def rhs_id(self): if hasattr(self, '_m_rhs_id'): return self._m_rhs_id self._m_rhs_id = self.base.rhs_id return getattr(self, '_m_rhs_id', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class PackageContentConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_num: self.material_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_material_num(self): if hasattr(self, '_m_has_field_material_num'): return self._m_has_field_material_num self._m_has_field_material_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_material_num', None) class ByteArray(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SwitchSkillIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_priority: self.priority = Output.EnumSwitchSkillPriority(self._io, self, self._root) if self.has_field_skill_index: self.skill_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_from_skill_id: self.from_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_to_skill_id: self.to_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_to_skill_id(self): if hasattr(self, '_m_has_field_to_skill_id'): return self._m_has_field_to_skill_id self._m_has_field_to_skill_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_to_skill_id', None) @property def has_field_from_skill_id(self): if hasattr(self, '_m_has_field_from_skill_id'): return self._m_has_field_from_skill_id self._m_has_field_from_skill_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_from_skill_id', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_skill_index(self): if hasattr(self, '_m_has_field_skill_index'): return self._m_has_field_skill_index self._m_has_field_skill_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_index', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ShaderLerpMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumEShaderData(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumSkillDrag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SkillDrag, self.data.value) return getattr(self, '_m_value', None) class WidgetActiveExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_guest_can_activate: self.is_guest_can_activate = self._io.read_u1() if self.has_field_active_gallery: self.active_gallery = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_active_region: self.active_region = AuxTypes.String(self._io, self, self._root) if self.has_field_active_scene: self.active_scene = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_is_guest_can_activate(self): if hasattr(self, '_m_has_field_is_guest_can_activate'): return self._m_has_field_is_guest_can_activate self._m_has_field_is_guest_can_activate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_guest_can_activate', None) @property def has_field_active_gallery(self): if hasattr(self, '_m_has_field_active_gallery'): return self._m_has_field_active_gallery self._m_has_field_active_gallery = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_active_gallery', None) @property def has_field_active_scene(self): if hasattr(self, '_m_has_field_active_scene'): return self._m_has_field_active_scene self._m_has_field_active_scene = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_active_scene', None) @property def has_field_active_region(self): if hasattr(self, '_m_has_field_active_region'): return self._m_has_field_active_region self._m_has_field_active_region = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_active_region', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) class ConfigAiReactActionPointData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_react_list: self.react_list = Output.ArrayOfConfigAiPickActionPointCriteriaLengthU(self._io, self, self._root) @property def has_field_react_list(self): if hasattr(self, '_m_has_field_react_list'): return self._m_has_field_react_list self._m_has_field_react_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_react_list', None) class LevelOptionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessCardNumericalModificationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TrialAvatarExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_trial_avatar_id: self.trial_avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_param_list: self.trial_avatar_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_trial_skill_depot_id: self.trial_skill_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_dynamic_level: self.is_dynamic_level = self._io.read_u1() if self.has_field_specified_costume_id: self.specified_costume_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_trial_avatar_param_list(self): if hasattr(self, '_m_has_field_trial_avatar_param_list'): return self._m_has_field_trial_avatar_param_list self._m_has_field_trial_avatar_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_trial_avatar_param_list', None) @property def has_field_is_dynamic_level(self): if hasattr(self, '_m_has_field_is_dynamic_level'): return self._m_has_field_is_dynamic_level self._m_has_field_is_dynamic_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_dynamic_level', None) @property def has_field_trial_avatar_id(self): if hasattr(self, '_m_has_field_trial_avatar_id'): return self._m_has_field_trial_avatar_id self._m_has_field_trial_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_trial_avatar_id', None) @property def has_field_specified_costume_id(self): if hasattr(self, '_m_has_field_specified_costume_id'): return self._m_has_field_specified_costume_id self._m_has_field_specified_costume_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_specified_costume_id', None) @property def has_field_trial_skill_depot_id(self): if hasattr(self, '_m_has_field_trial_skill_depot_id'): return self._m_has_field_trial_skill_depot_id self._m_has_field_trial_skill_depot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_trial_skill_depot_id', None) class EnumAnimeGroupType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimeGroupType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeUConfigGadgetTurnState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigGadgetTurnState(self._io, self, self._root) class LuaTaskTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityHideAndSeekBasicConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGearGadgetJigsawExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_place_pos_id: self.place_pos_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate_effect: self.rotate_effect = AuxTypes.String(self._io, self, self._root) @property def has_field_rotate_effect(self): if hasattr(self, '_m_has_field_rotate_effect'): return self._m_has_field_rotate_effect self._m_has_field_rotate_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_rotate_effect', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_place_pos_id(self): if hasattr(self, '_m_has_field_place_pos_id'): return self._m_has_field_place_pos_id self._m_has_field_place_pos_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_place_pos_id', None) class DispAudioSettingSlider(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.AudioSettingSlider(self._io, self, self._root) elif _on == 1: self.data = Output.AudioSettingSliderPostEvent(self._io, self, self._root) elif _on == 2: self.data = Output.AudioSettingSliderPostVoice(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class InputActionEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_event_type: self.event_type = Output.EnumInputEventType(self._io, self, self._root) if self.has_field_next_to_handle: self.next_to_handle = Output.EnumContextEventType(self._io, self, self._root) if self.has_field_event_config: self.event_config = Output.ConfigBaseInputEvent(self._io, self, self._root) if self.has_field_proxy_event_type: self.proxy_event_type = Output.EnumInputEventType(self._io, self, self._root) if self.has_field_context_event: self.context_event = Output.EnumContextEventType(self._io, self, self._root) @property def has_field_event_config(self): if hasattr(self, '_m_has_field_event_config'): return self._m_has_field_event_config self._m_has_field_event_config = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_event_config', None) @property def has_field_proxy_event_type(self): if hasattr(self, '_m_has_field_proxy_event_type'): return self._m_has_field_proxy_event_type self._m_has_field_proxy_event_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_proxy_event_type', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_event_type(self): if hasattr(self, '_m_has_field_event_type'): return self._m_has_field_event_type self._m_has_field_event_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_type', None) @property def has_field_context_event(self): if hasattr(self, '_m_has_field_context_event'): return self._m_has_field_context_event self._m_has_field_context_event = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_context_event', None) @property def has_field_next_to_handle(self): if hasattr(self, '_m_has_field_next_to_handle'): return self._m_has_field_next_to_handle self._m_has_field_next_to_handle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_to_handle', None) class EnumControlPartRotateBy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ControlPartRotateBy, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigMatLinearChangedByDistanceLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMatLinearChangedByDistance(self._io, self, self._root)) class ShaderUseTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProgressBillboardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InterruptButtonTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachToDayNightMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_time: self.time = Output.EnumLevelDayTimeType(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class PickTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumProgressBillboardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProgressBillboardType, self.data.value) return getattr(self, '_m_value', None) class SetAiParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_param: self.param = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_is_bool: self.is_bool = self._io.read_u1() if self.has_field_logic_type: self.logic_type = Output.EnumParamLogicType(self._io, self, self._root) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_is_bool(self): if hasattr(self, '_m_has_field_is_bool'): return self._m_has_field_is_bool self._m_has_field_is_bool = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_bool', None) @property def has_field_logic_type(self): if hasattr(self, '_m_has_field_logic_type'): return self._m_has_field_logic_type self._m_has_field_logic_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_logic_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigGuideGeneralCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class DigOverAllExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_duration: self.duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_unlock_id: self.quest_unlock_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_unlock_id: self.stage_unlock_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_quest_show_cond: self.end_quest_show_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_quest_finish_cond: self.end_quest_finish_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_end_quest_id: self.end_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_unlock_id(self): if hasattr(self, '_m_has_field_stage_unlock_id'): return self._m_has_field_stage_unlock_id self._m_has_field_stage_unlock_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_stage_unlock_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_duration', None) @property def has_field_end_quest_show_cond(self): if hasattr(self, '_m_has_field_end_quest_show_cond'): return self._m_has_field_end_quest_show_cond self._m_has_field_end_quest_show_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_end_quest_show_cond', None) @property def has_field_quest_unlock_id(self): if hasattr(self, '_m_has_field_quest_unlock_id'): return self._m_has_field_quest_unlock_id self._m_has_field_quest_unlock_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_unlock_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_end_quest_id(self): if hasattr(self, '_m_has_field_end_quest_id'): return self._m_has_field_end_quest_id self._m_has_field_end_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_end_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_end_quest_finish_cond(self): if hasattr(self, '_m_has_field_end_quest_finish_cond'): return self._m_has_field_end_quest_finish_cond self._m_has_field_end_quest_finish_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_end_quest_finish_cond', None) class ArrayOfConfigHomeFurnitureSuiteLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeFurnitureSuite(self._io, self, self._root)) class ConfigGuideCameraCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action: self.action = Output.EnumGuideCameraAction(self._io, self, self._root) if self.has_field_param: self.param = self._io.read_f4le() @property def has_field_action(self): if hasattr(self, '_m_has_field_action'): return self._m_has_field_action self._m_has_field_action = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ConfigLevelRoute(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_routes: self.routes = Output.ArrayOfConfigRouteLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_routes(self): if hasattr(self, '_m_has_field_routes'): return self._m_has_field_routes self._m_has_field_routes = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_routes', None) class SetChargeRatio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_charge_type: self.charge_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_ratio: self.ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_charge_type(self): if hasattr(self, '_m_has_field_charge_type'): return self._m_has_field_charge_type self._m_has_field_charge_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_charge_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ratio', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumItemUseOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemUseOp, self.data.value) return getattr(self, '_m_value', None) class AsterPhaseComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSkinFashionGadgets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_old_gadgets: self.old_gadgets = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_new_gadgets: self.new_gadgets = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_old_gadgets(self): if hasattr(self, '_m_has_field_old_gadgets'): return self._m_has_field_old_gadgets self._m_has_field_old_gadgets = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_old_gadgets', None) @property def has_field_new_gadgets(self): if hasattr(self, '_m_has_field_new_gadgets'): return self._m_has_field_new_gadgets self._m_has_field_new_gadgets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_new_gadgets', None) class LandSoundExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerTaunt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_taunt_level: self.taunt_level = Output.EnumTauntLevel(self._io, self, self._root) if self.has_field_care_value: self.care_value = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_taunt_level(self): if hasattr(self, '_m_has_field_taunt_level'): return self._m_has_field_taunt_level self._m_has_field_taunt_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_taunt_level', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_care_value(self): if hasattr(self, '_m_has_field_care_value'): return self._m_has_field_care_value self._m_has_field_care_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_care_value', None) class EnumMassiveElementTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MassiveElementTriggerType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigEffectPoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigEffectPoolItem(self._io, self, self._root)) class ConfigAiCrabMoveSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiCrabMoveData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiCrabMoveData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class RoguelikeShikigamiGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeWatcherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LunaRitePreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PaimonAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_: self.from_ = Output.EnumPaimonRequestFrom(self._io, self, self._root) if self.has_field_action_name: self.action_name = Output.EnumPaimonSkill(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_action_name(self): if hasattr(self, '_m_has_field_action_name'): return self._m_has_field_action_name self._m_has_field_action_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_name', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_from_(self): if hasattr(self, '_m_has_field_from_'): return self._m_has_field_from_ self._m_has_field_from_ = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_', None) class BonusActivityClientExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_activity_type: self.bonus_activity_type = Output.EnumBonusActivityType(self._io, self, self._root) if self.has_field_avatar_config_id: self.avatar_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_index_list: self.voice_index_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_player_level: self.open_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfab_path: self.perfab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_unlock_tips: self.unlock_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bonus_activity_type(self): if hasattr(self, '_m_has_field_bonus_activity_type'): return self._m_has_field_bonus_activity_type self._m_has_field_bonus_activity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_bonus_activity_type', None) @property def has_field_open_player_level(self): if hasattr(self, '_m_has_field_open_player_level'): return self._m_has_field_open_player_level self._m_has_field_open_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_player_level', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_avatar_config_id(self): if hasattr(self, '_m_has_field_avatar_config_id'): return self._m_has_field_avatar_config_id self._m_has_field_avatar_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_avatar_config_id', None) @property def has_field_perfab_path(self): if hasattr(self, '_m_has_field_perfab_path'): return self._m_has_field_perfab_path self._m_has_field_perfab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_perfab_path', None) @property def has_field_voice_index_list(self): if hasattr(self, '_m_has_field_voice_index_list'): return self._m_has_field_voice_index_list self._m_has_field_voice_index_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_voice_index_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_unlock_tips(self): if hasattr(self, '_m_has_field_unlock_tips'): return self._m_has_field_unlock_tips self._m_has_field_unlock_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_tips', None) class ReminderIndexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_id: self.reminder_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumReminderShowType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_reminder_id(self): if hasattr(self, '_m_has_field_reminder_id'): return self._m_has_field_reminder_id self._m_has_field_reminder_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reminder_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_show_type', None) class KvpOfDictAuxTypesStringConfigAbilityModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAbilityModifier(self._io, self, self._root) class ConfigGadgetPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_collision: self.collision = Output.ConfigCollision(self._io, self, self._root) if self.has_field_collider_check_on_init: self.collider_check_on_init = self._io.read_u1() @property def has_field_collision(self): if hasattr(self, '_m_has_field_collision'): return self._m_has_field_collision self._m_has_field_collision = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_collision', None) @property def has_field_collider_check_on_init(self): if hasattr(self, '_m_has_field_collider_check_on_init'): return self._m_has_field_collider_check_on_init self._m_has_field_collider_check_on_init = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_collider_check_on_init', None) class BlessingScanExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispContextActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispContextAction(self._io, self, self._root)) class EnumStateAudioEventUsage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StateAudioEventUsage, self.data.value) return getattr(self, '_m_value', None) class BattlePassMissionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_refresh_type: self.refresh_type = Output.EnumBattlePassMissionRefreshType(self._io, self, self._root) if self.has_field_is_force: self.is_force = self._io.read_u1() if self.has_field_add_point: self.add_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide: self.guide = Output.QuestGuide(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_add_point(self): if hasattr(self, '_m_has_field_add_point'): return self._m_has_field_add_point self._m_has_field_add_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_add_point', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_guide(self): if hasattr(self, '_m_has_field_guide'): return self._m_has_field_guide self._m_has_field_guide = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_guide', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_refresh_type(self): if hasattr(self, '_m_has_field_refresh_type'): return self._m_has_field_refresh_type self._m_has_field_refresh_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_refresh_type', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_trigger_config', None) @property def has_field_is_force(self): if hasattr(self, '_m_has_field_is_force'): return self._m_has_field_is_force self._m_has_field_is_force = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_force', None) class ColliderTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumPerfRatingCategoryArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPerfRatingCategory(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) class Randomed(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_chance: self.chance = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_success_actions: self.success_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_chance(self): if hasattr(self, '_m_has_field_chance'): return self._m_has_field_chance self._m_has_field_chance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_chance', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fail_actions', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_success_actions(self): if hasattr(self, '_m_has_field_success_actions'): return self._m_has_field_success_actions self._m_has_field_success_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_success_actions', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiOrderMasterSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_servant_slot_amount: self.servant_slot_amount = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_servant_slot_amount(self): if hasattr(self, '_m_has_field_servant_slot_amount'): return self._m_has_field_servant_slot_amount self._m_has_field_servant_slot_amount = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_servant_slot_amount', None) class ElementTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PhotographCheckAnimatorDataLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MapAreaStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DragonSpineStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_id_list: self.coin_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_openday: self.openday = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mission_id_list: self.mission_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_coin_id_list(self): if hasattr(self, '_m_has_field_coin_id_list'): return self._m_has_field_coin_id_list self._m_has_field_coin_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_coin_id_list', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_mission_id_list(self): if hasattr(self, '_m_has_field_mission_id_list'): return self._m_has_field_mission_id_list self._m_has_field_mission_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_mission_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_openday(self): if hasattr(self, '_m_has_field_openday'): return self._m_has_field_openday self._m_has_field_openday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_openday', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class EnablePositionSynchronization(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigMusicStringContainmentCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicStringCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CoopCondGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cond_comb_type: self.cond_comb_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_coop_cond_list: self.coop_cond_list = Output.ArrayOfCoopCondLengthU(self._io, self, self._root) @property def has_field_cond_comb_type(self): if hasattr(self, '_m_has_field_cond_comb_type'): return self._m_has_field_cond_comb_type self._m_has_field_cond_comb_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cond_comb_type', None) @property def has_field_coop_cond_list(self): if hasattr(self, '_m_has_field_coop_cond_list'): return self._m_has_field_coop_cond_list self._m_has_field_coop_cond_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_coop_cond_list', None) class RotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDungeonListLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DungeonList(self._io, self, self._root)) class EnumHomeAvatarEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HomeAvatarEventType, self.data.value) return getattr(self, '_m_value', None) class ActivityTanukiTravelRouteDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HideAndSeekAvatarSdExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) class ConfigFireGrassAirflowField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAirflowField(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_trigger_num: self.trigger_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_height_speed: self.height_speed = self._io.read_f4le() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_height', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def scale(self): if hasattr(self, '_m_scale'): return self._m_scale self._m_scale = self.base.scale return getattr(self, '_m_scale', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def stay_effect(self): if hasattr(self, '_m_stay_effect'): return self._m_stay_effect self._m_stay_effect = self.base.stay_effect return getattr(self, '_m_stay_effect', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def auto_fly(self): if hasattr(self, '_m_auto_fly'): return self._m_auto_fly self._m_auto_fly = self.base.auto_fly return getattr(self, '_m_auto_fly', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def enter_effect(self): if hasattr(self, '_m_enter_effect'): return self._m_enter_effect self._m_enter_effect = self.base.enter_effect return getattr(self, '_m_enter_effect', None) @property def force_hor(self): if hasattr(self, '_m_force_hor'): return self._m_force_hor self._m_force_hor = self.base.force_hor return getattr(self, '_m_force_hor', None) @property def has_field_trigger_num(self): if hasattr(self, '_m_has_field_trigger_num'): return self._m_has_field_trigger_num self._m_has_field_trigger_num = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_num', None) @property def has_field_height_speed(self): if hasattr(self, '_m_has_field_height_speed'): return self._m_has_field_height_speed self._m_has_field_height_speed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_height_speed', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class DictOfEnumPerfRatingCategoryArrayOfConfigPerfRatingLevelLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPerfRatingCategoryArrayOfConfigPerfRatingLevelLengthU(self._io, self, self._root)) class ConfigScenePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumScenePointType(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) if self.has_field_tran_pos: self.tran_pos = Output.Vector(self._io, self, self._root) if self.has_field_tran_rot: self.tran_rot = Output.Vector(self._io, self, self._root) if self.has_field_unlocked: self.unlocked = self._io.read_u1() if self.has_field_alias: self.alias = AuxTypes.String(self._io, self, self._root) if self.has_field_group_limit: self.group_limit = self._io.read_u1() if self.has_field_is_model_hidden: self.is_model_hidden = self._io.read_u1() @property def has_field_unlocked(self): if hasattr(self, '_m_has_field_unlocked'): return self._m_has_field_unlocked self._m_has_field_unlocked = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_unlocked', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_tran_pos(self): if hasattr(self, '_m_has_field_tran_pos'): return self._m_has_field_tran_pos self._m_has_field_tran_pos = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_tran_pos', None) @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_rot', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_is_model_hidden(self): if hasattr(self, '_m_has_field_is_model_hidden'): return self._m_has_field_is_model_hidden self._m_has_field_is_model_hidden = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_is_model_hidden', None) @property def has_field_alias(self): if hasattr(self, '_m_has_field_alias'): return self._m_has_field_alias self._m_has_field_alias = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_alias', None) @property def has_field_tran_rot(self): if hasattr(self, '_m_has_field_tran_rot'): return self._m_has_field_tran_rot self._m_has_field_tran_rot = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_tran_rot', None) @property def has_field_group_limit(self): if hasattr(self, '_m_has_field_group_limit'): return self._m_has_field_group_limit self._m_has_field_group_limit = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_group_limit', None) class SubChallengeFadeOutTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByTargetPositionToSelfPosition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_compare_type: self.compare_type = Output.EnumTargetPosToSelfPosType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_compare_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class SbyteIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SignInCondExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiScriptedMoveToSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiScriptedMoveToData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiScriptedMoveToData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class GadgetGuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumGuestButtonShowType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_show_type', None) class EnumMarkOrder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkOrder, self.data.value) return getattr(self, '_m_value', None) class EnumChessCardTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardTag, self.data.value) return getattr(self, '_m_value', None) class ResetEnviroEular(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_eular_angles: self.eular_angles = Output.Vector(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_eular_angles(self): if hasattr(self, '_m_has_field_eular_angles'): return self._m_has_field_eular_angles self._m_has_field_eular_angles = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_eular_angles', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesStringDispConfigBaseWidget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigBaseWidget(self._io, self, self._root)) class RandomIdCountConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.String(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_count', None) class ArrayOfEnumModifierTagLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumModifierTag(self._io, self, self._root)) class BartenderAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_type: self.order_type = Output.EnumOrderingType(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_count: self.material_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_order_type(self): if hasattr(self, '_m_has_field_order_type'): return self._m_has_field_order_type self._m_has_field_order_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order_type', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_material_count(self): if hasattr(self, '_m_has_field_material_count'): return self._m_has_field_material_count self._m_has_field_material_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_material_count', None) class FollowAttachPointEffectMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_priority: self.attach_priority = Output.EnumFollowAttachOccupyPriority(self._io, self, self._root) if self.has_field_refresh_on_avatar_in: self.refresh_on_avatar_in = self._io.read_u1() @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_attach_priority(self): if hasattr(self, '_m_has_field_attach_priority'): return self._m_has_field_attach_priority self._m_has_field_attach_priority = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_priority', None) @property def has_field_refresh_on_avatar_in(self): if hasattr(self, '_m_has_field_refresh_on_avatar_in'): return self._m_has_field_refresh_on_avatar_in self._m_has_field_refresh_on_avatar_in = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_refresh_on_avatar_in', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumGatherSaveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GatherSaveType, self.data.value) return getattr(self, '_m_value', None) class QuestElemSample(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.String(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_content', None) class MusicStimulusComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiSkillGroupCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_skill_group_cdid: self.skill_group_cdid = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_skill_group_cd_time: self.skill_group_cd_time = self._io.read_f4le() @property def has_field_skill_group_cdid(self): if hasattr(self, '_m_has_field_skill_group_cdid'): return self._m_has_field_skill_group_cdid self._m_has_field_skill_group_cdid = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_group_cdid', None) @property def has_field_skill_group_cd_time(self): if hasattr(self, '_m_has_field_skill_group_cd_time'): return self._m_has_field_skill_group_cd_time self._m_has_field_skill_group_cd_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_skill_group_cd_time', None) class LocalAvatarsMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EchoShellExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigLevelBlockLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelBlock(self._io, self, self._root)) class KvpOfDictAuxTypesStringDispConfigBaseStateLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigBaseStateLayer(self._io, self, self._root) class DungeonLevelEntityConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetUseAttachAbilityTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_ability_name: self.trigger_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_team: self.is_team = self._io.read_u1() @property def has_field_is_team(self): if hasattr(self, '_m_has_field_is_team'): return self._m_has_field_is_team self._m_has_field_is_team = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_team', None) @property def has_field_trigger_ability_name(self): if hasattr(self, '_m_has_field_trigger_ability_name'): return self._m_has_field_trigger_ability_name self._m_has_field_trigger_ability_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_ability_name', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class MainCoopExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_coop_cfg: self.main_coop_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_main_quest_series: self.main_quest_series = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_main_coop_cfg(self): if hasattr(self, '_m_has_field_main_coop_cfg'): return self._m_has_field_main_coop_cfg self._m_has_field_main_coop_cfg = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_main_coop_cfg', None) @property def has_field_main_quest_series(self): if hasattr(self, '_m_has_field_main_quest_series'): return self._m_has_field_main_quest_series self._m_has_field_main_quest_series = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_main_quest_series', None) class EnumReputationEntranceCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReputationEntranceCondType, self.data.value) return getattr(self, '_m_value', None) class ActivityChessGearExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EmojiSetDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SteerAttackMoveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SteerAttackMixin(self._io, self, self._root) @property def start_normalized_time(self): if hasattr(self, '_m_start_normalized_time'): return self._m_start_normalized_time self._m_start_normalized_time = self.base.start_normalized_time return getattr(self, '_m_start_normalized_time', None) @property def steer_state_i_ds(self): if hasattr(self, '_m_steer_state_i_ds'): return self._m_steer_state_i_ds self._m_steer_state_i_ds = self.base.steer_state_i_ds return getattr(self, '_m_steer_state_i_ds', None) @property def attack_distance(self): if hasattr(self, '_m_attack_distance'): return self._m_attack_distance self._m_attack_distance = self.base.attack_distance return getattr(self, '_m_attack_distance', None) @property def attack_trigger(self): if hasattr(self, '_m_attack_trigger'): return self._m_attack_trigger self._m_attack_trigger = self.base.attack_trigger return getattr(self, '_m_attack_trigger', None) @property def attack_angle(self): if hasattr(self, '_m_attack_angle'): return self._m_attack_angle self._m_attack_angle = self.base.attack_angle return getattr(self, '_m_attack_angle', None) @property def end_normalized_time(self): if hasattr(self, '_m_end_normalized_time'): return self._m_end_normalized_time self._m_end_normalized_time = self.base.end_normalized_time return getattr(self, '_m_end_normalized_time', None) @property def remote_steer_to_local_target(self): if hasattr(self, '_m_remote_steer_to_local_target'): return self._m_remote_steer_to_local_target self._m_remote_steer_to_local_target = self.base.remote_steer_to_local_target return getattr(self, '_m_remote_steer_to_local_target', None) @property def facing_target_types(self): if hasattr(self, '_m_facing_target_types'): return self._m_facing_target_types self._m_facing_target_types = self.base.facing_target_types return getattr(self, '_m_facing_target_types', None) @property def angular_speed(self): if hasattr(self, '_m_angular_speed'): return self._m_angular_speed self._m_angular_speed = self.base.angular_speed return getattr(self, '_m_angular_speed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigLocalGadgetOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_key: self.sub_key = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_opr_code: self.opr_code = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_euler: self.euler = Output.Vector(self._io, self, self._root) if self.has_field_gv_key: self.gv_key = AuxTypes.String(self._io, self, self._root) if self.has_field_gv_value: self.gv_value = self._io.read_f4le() if self.has_field_move_datas: self.move_datas = Output.ArrayOfConfigLocalGadgetMoveOpLengthU(self._io, self, self._root) if self.has_field_cmd_list: self.cmd_list = Output.ArrayOfDispConfigLocalGadgetCmdLengthU(self._io, self, self._root) @property def has_field_opr_code(self): if hasattr(self, '_m_has_field_opr_code'): return self._m_has_field_opr_code self._m_has_field_opr_code = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_opr_code', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_euler(self): if hasattr(self, '_m_has_field_euler'): return self._m_has_field_euler self._m_has_field_euler = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_euler', None) @property def has_field_sub_key(self): if hasattr(self, '_m_has_field_sub_key'): return self._m_has_field_sub_key self._m_has_field_sub_key = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_sub_key', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_gv_key(self): if hasattr(self, '_m_has_field_gv_key'): return self._m_has_field_gv_key self._m_has_field_gv_key = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gv_key', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_move_datas(self): if hasattr(self, '_m_has_field_move_datas'): return self._m_has_field_move_datas self._m_has_field_move_datas = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_move_datas', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_position', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_cmd_list(self): if hasattr(self, '_m_has_field_cmd_list'): return self._m_has_field_cmd_list self._m_has_field_cmd_list = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_cmd_list', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_gv_value(self): if hasattr(self, '_m_has_field_gv_value'): return self._m_has_field_gv_value self._m_has_field_gv_value = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_gv_value', None) class PhotographPoseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdActivityRestriction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_activity_type: self.activity_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_active: self.is_active = self._io.read_u1() if self.has_field_activity_phase: self.activity_phase = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_activity_type(self): if hasattr(self, '_m_has_field_activity_type'): return self._m_has_field_activity_type self._m_has_field_activity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_activity_type', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_active', None) @property def has_field_activity_phase(self): if hasattr(self, '_m_has_field_activity_phase'): return self._m_has_field_activity_phase self._m_has_field_activity_phase = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_activity_phase', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cond_id', None) class CompoundExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FurnitureMakeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_item_id: self.furniture_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_items: self.material_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_make_time: self.make_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_accelerate_time: self.max_accelerate_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quick_fetch_material_num: self.quick_fetch_material_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_furniture_item_id(self): if hasattr(self, '_m_has_field_furniture_item_id'): return self._m_has_field_furniture_item_id self._m_has_field_furniture_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_furniture_item_id', None) @property def has_field_make_time(self): if hasattr(self, '_m_has_field_make_time'): return self._m_has_field_make_time self._m_has_field_make_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_make_time', None) @property def has_field_max_accelerate_time(self): if hasattr(self, '_m_has_field_max_accelerate_time'): return self._m_has_field_max_accelerate_time self._m_has_field_max_accelerate_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_max_accelerate_time', None) @property def has_field_material_items(self): if hasattr(self, '_m_has_field_material_items'): return self._m_has_field_material_items self._m_has_field_material_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_material_items', None) @property def has_field_quick_fetch_material_num(self): if hasattr(self, '_m_has_field_quick_fetch_material_num'): return self._m_has_field_quick_fetch_material_num self._m_has_field_quick_fetch_material_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_quick_fetch_material_num', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_count', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_exp', None) class ReviveStamina(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class FlightActivityDayExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrLayerLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_layer_name_hash: self.layer_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_virtual_objects: self.virtual_objects = Output.ArrayOfSectrStreamObjectLengthU(self._io, self, self._root) @property def has_field_layer_name_hash(self): if hasattr(self, '_m_has_field_layer_name_hash'): return self._m_has_field_layer_name_hash self._m_has_field_layer_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_layer_name_hash', None) @property def has_field_virtual_objects(self): if hasattr(self, '_m_has_field_virtual_objects'): return self._m_has_field_virtual_objects self._m_has_field_virtual_objects = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_virtual_objects', None) class ConfigRandomQuestGlobalScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_talk_list: self.talk_list = Output.ArrayOfConfigRandomTalkSchemeLengthU(self._io, self, self._root) if self.has_field_quest_list: self.quest_list = Output.ArrayOfConfigRandomQuestSchemeLengthU(self._io, self, self._root) @property def has_field_talk_list(self): if hasattr(self, '_m_has_field_talk_list'): return self._m_has_field_talk_list self._m_has_field_talk_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_list', None) @property def has_field_quest_list(self): if hasattr(self, '_m_has_field_quest_list'): return self._m_has_field_quest_list self._m_has_field_quest_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_list', None) class AssocTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumNewActivityCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NewActivityCondType, self.data.value) return getattr(self, '_m_value', None) class PropValConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prop_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_value', None) class TreasureMapRegionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_token_num: self.token_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_center: self.region_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_region_radius: self.region_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_entry_id: self.region_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_list: self.group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spot_num_list: self.spot_num_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_token_num_list: self.token_num_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_misc_drop_prob_list: self.misc_drop_prob_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_misc_drop_id: self.misc_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_group_id: self.mp_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_backup_group_list: self.backup_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mp_token_threshold: self.mp_token_threshold = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_type_id: self.mp_type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_position: self.mp_position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_mp_desc: self.mp_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_reward_preview_id: self.mp_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fragment_bonus_id: self.fragment_bonus_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_mp_token_threshold(self): if hasattr(self, '_m_has_field_mp_token_threshold'): return self._m_has_field_mp_token_threshold self._m_has_field_mp_token_threshold = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_mp_token_threshold', None) @property def has_field_misc_drop_id(self): if hasattr(self, '_m_has_field_misc_drop_id'): return self._m_has_field_misc_drop_id self._m_has_field_misc_drop_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_misc_drop_id', None) @property def has_field_misc_drop_prob_list(self): if hasattr(self, '_m_has_field_misc_drop_prob_list'): return self._m_has_field_misc_drop_prob_list self._m_has_field_misc_drop_prob_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_misc_drop_prob_list', None) @property def has_field_fragment_bonus_id(self): if hasattr(self, '_m_has_field_fragment_bonus_id'): return self._m_has_field_fragment_bonus_id self._m_has_field_fragment_bonus_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_fragment_bonus_id', None) @property def has_field_region_radius(self): if hasattr(self, '_m_has_field_region_radius'): return self._m_has_field_region_radius self._m_has_field_region_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_region_radius', None) @property def has_field_mp_group_id(self): if hasattr(self, '_m_has_field_mp_group_id'): return self._m_has_field_mp_group_id self._m_has_field_mp_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_mp_group_id', None) @property def has_field_mp_position(self): if hasattr(self, '_m_has_field_mp_position'): return self._m_has_field_mp_position self._m_has_field_mp_position = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_mp_position', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_spot_num_list(self): if hasattr(self, '_m_has_field_spot_num_list'): return self._m_has_field_spot_num_list self._m_has_field_spot_num_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_spot_num_list', None) @property def has_field_group_list(self): if hasattr(self, '_m_has_field_group_list'): return self._m_has_field_group_list self._m_has_field_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_group_list', None) @property def has_field_mp_desc(self): if hasattr(self, '_m_has_field_mp_desc'): return self._m_has_field_mp_desc self._m_has_field_mp_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_mp_desc', None) @property def has_field_region_center(self): if hasattr(self, '_m_has_field_region_center'): return self._m_has_field_region_center self._m_has_field_region_center = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_region_center', None) @property def has_field_mp_reward_preview_id(self): if hasattr(self, '_m_has_field_mp_reward_preview_id'): return self._m_has_field_mp_reward_preview_id self._m_has_field_mp_reward_preview_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_mp_reward_preview_id', None) @property def has_field_token_num(self): if hasattr(self, '_m_has_field_token_num'): return self._m_has_field_token_num self._m_has_field_token_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_token_num', None) @property def has_field_mp_type_id(self): if hasattr(self, '_m_has_field_mp_type_id'): return self._m_has_field_mp_type_id self._m_has_field_mp_type_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_mp_type_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_backup_group_list(self): if hasattr(self, '_m_has_field_backup_group_list'): return self._m_has_field_backup_group_list self._m_has_field_backup_group_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_backup_group_list', None) @property def has_field_token_num_list(self): if hasattr(self, '_m_has_field_token_num_list'): return self._m_has_field_token_num_list self._m_has_field_token_num_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_token_num_list', None) @property def has_field_region_entry_id(self): if hasattr(self, '_m_has_field_region_entry_id'): return self._m_has_field_region_entry_id self._m_has_field_region_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_region_entry_id', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_revise_level', None) class ArrayOfMatchCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MatchCond(self._io, self, self._root)) class ConfigCrowdGroupInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_crowd_group_id: self.crowd_group_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_bound_center: self.bound_center = Output.Vector(self._io, self, self._root) if self.has_field_bound_size: self.bound_size = Output.Vector(self._io, self, self._root) if self.has_field_spawn_by_default: self.spawn_by_default = self._io.read_u1() if self.has_field_crowd_restriction_groups: self.crowd_restriction_groups = Output.ArrayOfConfigCrowdRestrictionGroupLengthU(self._io, self, self._root) if self.has_field_cutscene_id: self.cutscene_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ignore_low_perf_mode: self.ignore_low_perf_mode = self._io.read_u1() if self.has_field_joint_blocks: self.joint_blocks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_can_be_optimized: self.can_be_optimized = self._io.read_u1() @property def has_field_ignore_low_perf_mode(self): if hasattr(self, '_m_has_field_ignore_low_perf_mode'): return self._m_has_field_ignore_low_perf_mode self._m_has_field_ignore_low_perf_mode = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ignore_low_perf_mode', None) @property def has_field_crowd_restriction_groups(self): if hasattr(self, '_m_has_field_crowd_restriction_groups'): return self._m_has_field_crowd_restriction_groups self._m_has_field_crowd_restriction_groups = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_crowd_restriction_groups', None) @property def has_field_joint_blocks(self): if hasattr(self, '_m_has_field_joint_blocks'): return self._m_has_field_joint_blocks self._m_has_field_joint_blocks = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_joint_blocks', None) @property def has_field_bound_center(self): if hasattr(self, '_m_has_field_bound_center'): return self._m_has_field_bound_center self._m_has_field_bound_center = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_bound_center', None) @property def has_field_crowd_group_id(self): if hasattr(self, '_m_has_field_crowd_group_id'): return self._m_has_field_crowd_group_id self._m_has_field_crowd_group_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_crowd_group_id', None) @property def has_field_bound_size(self): if hasattr(self, '_m_has_field_bound_size'): return self._m_has_field_bound_size self._m_has_field_bound_size = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_bound_size', None) @property def has_field_spawn_by_default(self): if hasattr(self, '_m_has_field_spawn_by_default'): return self._m_has_field_spawn_by_default self._m_has_field_spawn_by_default = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_spawn_by_default', None) @property def has_field_can_be_optimized(self): if hasattr(self, '_m_has_field_can_be_optimized'): return self._m_has_field_can_be_optimized self._m_has_field_can_be_optimized = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_can_be_optimized', None) @property def has_field_cutscene_id(self): if hasattr(self, '_m_has_field_cutscene_id'): return self._m_has_field_cutscene_id self._m_has_field_cutscene_id = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_cutscene_id', None) class SelectTargetsByChildrenEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_type', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class HomeWorldBgmExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarHeroEntityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_animator_config_path_hash: self.animator_config_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_animator_config_path_hash: self.animator_config_path_hash_pre = self._io.read_s1() @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_animator_config_path_hash(self): if hasattr(self, '_m_has_field_animator_config_path_hash'): return self._m_has_field_animator_config_path_hash self._m_has_field_animator_config_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_animator_config_path_hash', None) class EnumGuideKeyClick(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideKeyClick, self.data.value) return getattr(self, '_m_value', None) class ActivityTanukiTravelDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlayScoreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerHideWeapon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_visible: self.visible = self._io.read_u1() if self.has_field_part_names: self.part_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_modify_another_value: self.modify_another_value = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_visible(self): if hasattr(self, '_m_has_field_visible'): return self._m_has_field_visible self._m_has_field_visible = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_visible', None) @property def has_field_part_names(self): if hasattr(self, '_m_has_field_part_names'): return self._m_has_field_part_names self._m_has_field_part_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_part_names', None) @property def has_field_modify_another_value(self): if hasattr(self, '_m_has_field_modify_another_value'): return self._m_has_field_modify_another_value self._m_has_field_modify_another_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_modify_another_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesStringConfigCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigCombat(self._io, self, self._root)) class MoveCategoryAiComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class StoryCameraTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TauntLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopPointExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumCoopPointType(self._io, self, self._root) if self.has_field_accept_quest: self.accept_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_post_point_list: self.post_point_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_point_name: self.point_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_dec: self.point_dec = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_pos_id: self.point_pos_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_photo_male_hash: self.photo_male_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_photo_male_hash: self.photo_male_hash_pre = self._io.read_s1() if self.has_field_photo_female_hash: self.photo_female_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_photo_female_hash: self.photo_female_hash_pre = self._io.read_s1() @property def has_field_accept_quest(self): if hasattr(self, '_m_has_field_accept_quest'): return self._m_has_field_accept_quest self._m_has_field_accept_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_accept_quest', None) @property def has_field_photo_female_hash(self): if hasattr(self, '_m_has_field_photo_female_hash'): return self._m_has_field_photo_female_hash self._m_has_field_photo_female_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_photo_female_hash', None) @property def has_field_photo_male_hash(self): if hasattr(self, '_m_has_field_photo_male_hash'): return self._m_has_field_photo_male_hash self._m_has_field_photo_male_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_photo_male_hash', None) @property def has_field_post_point_list(self): if hasattr(self, '_m_has_field_post_point_list'): return self._m_has_field_post_point_list self._m_has_field_post_point_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_post_point_list', None) @property def has_field_point_dec(self): if hasattr(self, '_m_has_field_point_dec'): return self._m_has_field_point_dec self._m_has_field_point_dec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_point_dec', None) @property def has_field_point_name(self): if hasattr(self, '_m_has_field_point_name'): return self._m_has_field_point_name self._m_has_field_point_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_point_name', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_point_pos_id(self): if hasattr(self, '_m_has_field_point_pos_id'): return self._m_has_field_point_pos_id self._m_has_field_point_pos_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_point_pos_id', None) class ArrayOfRandomQuestElemLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandomQuestElem(self._io, self, self._root)) class ReviveElemEnergy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_talk_id: self.talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDialogGroupSchemeType(self._io, self, self._root) if self.has_field_dialog_list: self.dialog_list = Output.ArrayOfConfigDialogSchemeLengthU(self._io, self, self._root) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_dialog_list(self): if hasattr(self, '_m_has_field_dialog_list'): return self._m_has_field_dialog_list self._m_has_field_dialog_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dialog_list', None) class ConfigGuideMechanicusCurseCardCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_has_curse: self.has_curse = self._io.read_u1() @property def has_field_has_curse(self): if hasattr(self, '_m_has_field_has_curse'): return self._m_has_field_has_curse self._m_has_field_has_curse = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_has_curse', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ArrayOfConfigGadgetConsoleLimitationLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetConsoleLimitation(self._io, self, self._root)) class RewardResourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExhibitionServerTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionServerTriggerType, self.data.value) return getattr(self, '_m_value', None) class ProudSkillOpenConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_proud_skill_group_id: self.proud_skill_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_avatar_promote_level: self.need_avatar_promote_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_proud_skill_group_id(self): if hasattr(self, '_m_has_field_proud_skill_group_id'): return self._m_has_field_proud_skill_group_id self._m_has_field_proud_skill_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_proud_skill_group_id', None) @property def has_field_need_avatar_promote_level(self): if hasattr(self, '_m_has_field_need_avatar_promote_level'): return self._m_has_field_need_avatar_promote_level self._m_has_field_need_avatar_promote_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_need_avatar_promote_level', None) class BinaryClipInfoSeralizer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class H5activityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterRarityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUCoopTempValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUCoopTempValue(self._io, self, self._root)) class AudioWeatherVoTriggerTimeRule(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_from_: self.from_ = self._io.read_f4le() if self.has_field_to: self.to = self._io.read_f4le() @property def has_field_from_(self): if hasattr(self, '_m_has_field_from_'): return self._m_has_field_from_ self._m_has_field_from_ = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_', None) @property def has_field_to(self): if hasattr(self, '_m_has_field_to'): return self._m_has_field_to self._m_has_field_to = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to', None) class ShowExtraAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfRandomQuestCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandomQuestCond(self._io, self, self._root)) class EnumMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoveType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumAbilityStateAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumAbilityState(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class EnumChestShowUiRemind(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChestShowUiRemind, self.data.value) return getattr(self, '_m_value', None) class AiTargetSystemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableLightCoreComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EchoShellStoryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCharacterAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEntityAudio(self._io, self, self._root) @property def destroy_event(self): if hasattr(self, '_m_destroy_event'): return self._m_destroy_event self._m_destroy_event = self.base.destroy_event return getattr(self, '_m_destroy_event', None) @property def anim_audio(self): if hasattr(self, '_m_anim_audio'): return self._m_anim_audio self._m_anim_audio = self.base.anim_audio return getattr(self, '_m_anim_audio', None) @property def disable_event(self): if hasattr(self, '_m_disable_event'): return self._m_disable_event self._m_disable_event = self.base.disable_event return getattr(self, '_m_disable_event', None) @property def enable_event(self): if hasattr(self, '_m_enable_event'): return self._m_enable_event self._m_enable_event = self.base.enable_event return getattr(self, '_m_enable_event', None) @property def init_event(self): if hasattr(self, '_m_init_event'): return self._m_init_event self._m_init_event = self.base.init_event return getattr(self, '_m_init_event', None) class EnumCutsceneType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CutsceneType, self.data.value) return getattr(self, '_m_value', None) class OfferingActionContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_action_type: self.action_type = Output.EnumOfferingActionType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_action_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ExcelTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfQteExecLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QteExec(self._io, self, self._root)) class BodyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QteStepCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class Uint64NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ConfigPerfNumberArrayItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_value: self.override_value = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_override_value(self): if hasattr(self, '_m_has_field_override_value'): return self._m_has_field_override_value self._m_has_field_override_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_value', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) class ConfigWidgetTreasureMapDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radius_succ: self.radius_succ = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_detect_range: self.detect_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_duration: self.gadget_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_radius_succ(self): if hasattr(self, '_m_has_field_radius_succ'): return self._m_has_field_radius_succ self._m_has_field_radius_succ = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius_succ', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_gadget_duration(self): if hasattr(self, '_m_has_field_gadget_duration'): return self._m_has_field_gadget_duration self._m_has_field_gadget_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_gadget_duration', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_detect_range(self): if hasattr(self, '_m_has_field_detect_range'): return self._m_has_field_detect_range self._m_has_field_detect_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_detect_range', None) class ReviveElemEnergyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) if self.has_field_period: self.period = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_base_energy: self.base_energy = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_ratio: self.ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_base_energy(self): if hasattr(self, '_m_has_field_base_energy'): return self._m_has_field_base_energy self._m_has_field_base_energy = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_base_energy', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ratio', None) @property def has_field_period(self): if hasattr(self, '_m_has_field_period'): return self._m_has_field_period self._m_has_field_period = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_period', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfFireElementAdditionConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FireElementAdditionConfig(self._io, self, self._root)) class TalentPointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WeatherTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPlayFrameFaceAnimationAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_animation: self.animation = AuxTypes.String(self._io, self, self._root) if self.has_field_mode: self.mode = Output.EnumFrameFaceAnimationPlayType(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_mode(self): if hasattr(self, '_m_has_field_mode'): return self._m_has_field_mode self._m_has_field_mode = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mode', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_animation(self): if hasattr(self, '_m_has_field_animation'): return self._m_has_field_animation self._m_has_field_animation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_animation', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigAiSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_type: self.skill_type = Output.EnumConfigAiSkillType(self._io, self, self._root) if self.has_field_combat_skill_type: self.combat_skill_type = Output.EnumConfigAiCombatSkillType(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_can_use_combat_skill_condition: self.can_use_combat_skill_condition = self._io.read_u1() if self.has_field_need_line_of_sight: self.need_line_of_sight = self._io.read_u1() if self.has_field_face_target: self.face_target = self._io.read_u1() if self.has_field_can_use_if_target_inactive: self.can_use_if_target_inactive = self._io.read_u1() if self.has_field_enable_skill_prepare: self.enable_skill_prepare = self._io.read_u1() if self.has_field_skill_prepare_timeout: self.skill_prepare_timeout = self._io.read_f4le() if self.has_field_skill_prepare_speed_level: self.skill_prepare_speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_cast_condition: self.cast_condition = Output.ConfigAiSkillCastCondition(self._io, self, self._root) if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_cd_upper_range: self.cd_upper_range = self._io.read_f4le() if self.has_field_initial_cd: self.initial_cd = self._io.read_f4le() if self.has_field_initial_cd_upper_range: self.initial_cd_upper_range = self._io.read_f4le() if self.has_field_public_cd_group: self.public_cd_group = AuxTypes.String(self._io, self, self._root) if self.has_field_ignore_gcd: self.ignore_gcd = self._io.read_u1() if self.has_field_trigger_gcd: self.trigger_gcd = self._io.read_u1() if self.has_field_trigger_cd_on_start: self.trigger_cd_on_start = self._io.read_u1() if self.has_field_trigger_cd_on_fail: self.trigger_cd_on_fail = self._io.read_u1() if self.has_field_skill_group_cdid: self.skill_group_cdid = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_state_i_ds: self.state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_skill_querying_time: self.skill_querying_time = self._io.read_f4le() if self.has_field_command_id: self.command_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_flag_target_reachable: self.flag_target_reachable = AuxTypes.String(self._io, self, self._root) if self.has_field_flag_self_on_template_collider: self.flag_self_on_template_collider = AuxTypes.String(self._io, self, self._root) if self.has_field_flag_self_in_zone: self.flag_self_in_zone = AuxTypes.String(self._io, self, self._root) if self.has_field_flag_target_in_zone: self.flag_target_in_zone = AuxTypes.String(self._io, self, self._root) if self.has_field_buddy_skill_condition: self.buddy_skill_condition = Output.ConfigAiBuddySkillCondition(self._io, self, self._root) if self.has_field_nerve_trigger: self.nerve_trigger = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) if self.has_field_nerve_target: self.nerve_target = Output.ConfigAiNerveSkill(self._io, self, self._root) @property def has_field_flag_target_in_zone(self): if hasattr(self, '_m_has_field_flag_target_in_zone'): return self._m_has_field_flag_target_in_zone self._m_has_field_flag_target_in_zone = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_flag_target_in_zone', None) @property def has_field_flag_target_reachable(self): if hasattr(self, '_m_has_field_flag_target_reachable'): return self._m_has_field_flag_target_reachable self._m_has_field_flag_target_reachable = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_flag_target_reachable', None) @property def has_field_cd_upper_range(self): if hasattr(self, '_m_has_field_cd_upper_range'): return self._m_has_field_cd_upper_range self._m_has_field_cd_upper_range = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_cd_upper_range', None) @property def has_field_face_target(self): if hasattr(self, '_m_has_field_face_target'): return self._m_has_field_face_target self._m_has_field_face_target = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_face_target', None) @property def has_field_skill_querying_time(self): if hasattr(self, '_m_has_field_skill_querying_time'): return self._m_has_field_skill_querying_time self._m_has_field_skill_querying_time = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_skill_querying_time', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_trigger_cd_on_start(self): if hasattr(self, '_m_has_field_trigger_cd_on_start'): return self._m_has_field_trigger_cd_on_start self._m_has_field_trigger_cd_on_start = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_trigger_cd_on_start', None) @property def has_field_nerve_trigger(self): if hasattr(self, '_m_has_field_nerve_trigger'): return self._m_has_field_nerve_trigger self._m_has_field_nerve_trigger = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_nerve_trigger', None) @property def has_field_cast_condition(self): if hasattr(self, '_m_has_field_cast_condition'): return self._m_has_field_cast_condition self._m_has_field_cast_condition = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_cast_condition', None) @property def has_field_nerve_target(self): if hasattr(self, '_m_has_field_nerve_target'): return self._m_has_field_nerve_target self._m_has_field_nerve_target = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_nerve_target', None) @property def has_field_initial_cd(self): if hasattr(self, '_m_has_field_initial_cd'): return self._m_has_field_initial_cd self._m_has_field_initial_cd = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_initial_cd', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_skill_type(self): if hasattr(self, '_m_has_field_skill_type'): return self._m_has_field_skill_type self._m_has_field_skill_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_skill_type', None) @property def has_field_flag_self_in_zone(self): if hasattr(self, '_m_has_field_flag_self_in_zone'): return self._m_has_field_flag_self_in_zone self._m_has_field_flag_self_in_zone = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_flag_self_in_zone', None) @property def has_field_trigger_cd_on_fail(self): if hasattr(self, '_m_has_field_trigger_cd_on_fail'): return self._m_has_field_trigger_cd_on_fail self._m_has_field_trigger_cd_on_fail = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_trigger_cd_on_fail', None) @property def has_field_buddy_skill_condition(self): if hasattr(self, '_m_has_field_buddy_skill_condition'): return self._m_has_field_buddy_skill_condition self._m_has_field_buddy_skill_condition = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_buddy_skill_condition', None) @property def has_field_ignore_gcd(self): if hasattr(self, '_m_has_field_ignore_gcd'): return self._m_has_field_ignore_gcd self._m_has_field_ignore_gcd = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_ignore_gcd', None) @property def has_field_can_use_if_target_inactive(self): if hasattr(self, '_m_has_field_can_use_if_target_inactive'): return self._m_has_field_can_use_if_target_inactive self._m_has_field_can_use_if_target_inactive = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_can_use_if_target_inactive', None) @property def has_field_trigger_gcd(self): if hasattr(self, '_m_has_field_trigger_gcd'): return self._m_has_field_trigger_gcd self._m_has_field_trigger_gcd = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_trigger_gcd', None) @property def has_field_enable_skill_prepare(self): if hasattr(self, '_m_has_field_enable_skill_prepare'): return self._m_has_field_enable_skill_prepare self._m_has_field_enable_skill_prepare = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enable_skill_prepare', None) @property def has_field_combat_skill_type(self): if hasattr(self, '_m_has_field_combat_skill_type'): return self._m_has_field_combat_skill_type self._m_has_field_combat_skill_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_combat_skill_type', None) @property def has_field_skill_prepare_timeout(self): if hasattr(self, '_m_has_field_skill_prepare_timeout'): return self._m_has_field_skill_prepare_timeout self._m_has_field_skill_prepare_timeout = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_skill_prepare_timeout', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def has_field_can_use_combat_skill_condition(self): if hasattr(self, '_m_has_field_can_use_combat_skill_condition'): return self._m_has_field_can_use_combat_skill_condition self._m_has_field_can_use_combat_skill_condition = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_can_use_combat_skill_condition', None) @property def has_field_skill_group_cdid(self): if hasattr(self, '_m_has_field_skill_group_cdid'): return self._m_has_field_skill_group_cdid self._m_has_field_skill_group_cdid = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_skill_group_cdid', None) @property def has_field_need_line_of_sight(self): if hasattr(self, '_m_has_field_need_line_of_sight'): return self._m_has_field_need_line_of_sight self._m_has_field_need_line_of_sight = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_need_line_of_sight', None) @property def has_field_flag_self_on_template_collider(self): if hasattr(self, '_m_has_field_flag_self_on_template_collider'): return self._m_has_field_flag_self_on_template_collider self._m_has_field_flag_self_on_template_collider = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_flag_self_on_template_collider', None) @property def has_field_public_cd_group(self): if hasattr(self, '_m_has_field_public_cd_group'): return self._m_has_field_public_cd_group self._m_has_field_public_cd_group = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_public_cd_group', None) @property def has_field_initial_cd_upper_range(self): if hasattr(self, '_m_has_field_initial_cd_upper_range'): return self._m_has_field_initial_cd_upper_range self._m_has_field_initial_cd_upper_range = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_initial_cd_upper_range', None) @property def has_field_command_id(self): if hasattr(self, '_m_has_field_command_id'): return self._m_has_field_command_id self._m_has_field_command_id = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_command_id', None) @property def has_field_skill_prepare_speed_level(self): if hasattr(self, '_m_has_field_skill_prepare_speed_level'): return self._m_has_field_skill_prepare_speed_level self._m_has_field_skill_prepare_speed_level = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_skill_prepare_speed_level', None) class DailyDungeonConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monday: self.monday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tuesday: self.tuesday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_wednesday: self.wednesday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_thursday: self.thursday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_friday: self.friday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_saturday: self.saturday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_sunday: self.sunday = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_tuesday(self): if hasattr(self, '_m_has_field_tuesday'): return self._m_has_field_tuesday self._m_has_field_tuesday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tuesday', None) @property def has_field_friday(self): if hasattr(self, '_m_has_field_friday'): return self._m_has_field_friday self._m_has_field_friday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_friday', None) @property def has_field_saturday(self): if hasattr(self, '_m_has_field_saturday'): return self._m_has_field_saturday self._m_has_field_saturday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_saturday', None) @property def has_field_wednesday(self): if hasattr(self, '_m_has_field_wednesday'): return self._m_has_field_wednesday self._m_has_field_wednesday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_wednesday', None) @property def has_field_sunday(self): if hasattr(self, '_m_has_field_sunday'): return self._m_has_field_sunday self._m_has_field_sunday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_sunday', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_monday(self): if hasattr(self, '_m_has_field_monday'): return self._m_has_field_monday self._m_has_field_monday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monday', None) @property def has_field_thursday(self): if hasattr(self, '_m_has_field_thursday'): return self._m_has_field_thursday self._m_has_field_thursday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_thursday', None) class QuestStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GalleryProgressScoreUiTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideCheckQuestStateCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_state: self.quest_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_equal: self.is_equal = self._io.read_u1() @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_quest_state(self): if hasattr(self, '_m_has_field_quest_state'): return self._m_has_field_quest_state self._m_has_field_quest_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_state', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_is_equal(self): if hasattr(self, '_m_has_field_is_equal'): return self._m_has_field_is_equal self._m_has_field_is_equal = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_equal', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class ConfigChangeNpcMatAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_renderer_name: self.renderer_name = AuxTypes.String(self._io, self, self._root) if self.has_field_mat_index: self.mat_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_mat_path: self.mat_path = AuxTypes.String(self._io, self, self._root) @property def has_field_renderer_name(self): if hasattr(self, '_m_has_field_renderer_name'): return self._m_has_field_renderer_name self._m_has_field_renderer_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_renderer_name', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_mat_index(self): if hasattr(self, '_m_has_field_mat_index'): return self._m_has_field_mat_index self._m_has_field_mat_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mat_index', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_mat_path(self): if hasattr(self, '_m_has_field_mat_path'): return self._m_has_field_mat_path self._m_has_field_mat_path = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_mat_path', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigWidgetLunchBoxHealMaterial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_notice_add_hp_materials: self.notice_add_hp_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_other_add_hp_materials: self.other_add_hp_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_notice_add_hp_materials(self): if hasattr(self, '_m_has_field_notice_add_hp_materials'): return self._m_has_field_notice_add_hp_materials self._m_has_field_notice_add_hp_materials = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_notice_add_hp_materials', None) @property def has_field_other_add_hp_materials(self): if hasattr(self, '_m_has_field_other_add_hp_materials'): return self._m_has_field_other_add_hp_materials self._m_has_field_other_add_hp_materials = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_other_add_hp_materials', None) class EnumConstValueType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConstValueType, self.data.value) return getattr(self, '_m_value', None) class ActivitySpiceFoodExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlayGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCodexQuestDialogSingle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_text: self.text = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_sound_id: self.sound_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_item_id: self.next_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_text(self): if hasattr(self, '_m_has_field_text'): return self._m_has_field_text self._m_has_field_text = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_text', None) @property def has_field_sound_id(self): if hasattr(self, '_m_has_field_sound_id'): return self._m_has_field_sound_id self._m_has_field_sound_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sound_id', None) @property def has_field_next_item_id(self): if hasattr(self, '_m_has_field_next_item_id'): return self._m_has_field_next_item_id self._m_has_field_next_item_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_item_id', None) class RogueDiaryDungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TouchInteractTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDistType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DistType, self.data.value) return getattr(self, '_m_value', None) class IrodoriMasterLevelTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCoopTalkNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCoopBaseNode(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_talk_id: self.talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_config: self.talk_config = Output.ConfigTalkScheme(self._io, self, self._root) @property def next_node_array(self): if hasattr(self, '_m_next_node_array'): return self._m_next_node_array self._m_next_node_array = self.base.next_node_array return getattr(self, '_m_next_node_array', None) @property def coop_node_id(self): if hasattr(self, '_m_coop_node_id'): return self._m_coop_node_id self._m_coop_node_id = self.base.coop_node_id return getattr(self, '_m_coop_node_id', None) @property def coop_node_type(self): if hasattr(self, '_m_coop_node_type'): return self._m_coop_node_type self._m_coop_node_type = self.base.coop_node_type return getattr(self, '_m_coop_node_type', None) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_id', None) @property def has_field_talk_config(self): if hasattr(self, '_m_has_field_talk_config'): return self._m_has_field_talk_config self._m_has_field_talk_config = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_talk_config', None) class KvpOfDictEnumInputActionTypeDispConfigBaseInputAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumInputActionType(self._io, self, self._root) self.value = Output.DispConfigBaseInputAction(self._io, self, self._root) class BanTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivitySaleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sale_type: self.sale_type = Output.EnumNewActivitySaleType(self._io, self, self._root) if self.has_field_sale_param: self.sale_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_bufftips: self.bufftips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sale_type(self): if hasattr(self, '_m_has_field_sale_type'): return self._m_has_field_sale_type self._m_has_field_sale_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sale_type', None) @property def has_field_sale_param(self): if hasattr(self, '_m_has_field_sale_param'): return self._m_has_field_sale_param self._m_has_field_sale_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sale_param', None) @property def has_field_bufftips(self): if hasattr(self, '_m_has_field_bufftips'): return self._m_has_field_bufftips self._m_has_field_bufftips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_bufftips', None) class DictOfAuxTypesVlqBase128LeSConfigAiCombatFollowMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiCombatFollowMoveData(self._io, self, self._root)) class AttackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachModifierByActivityGachaStageMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_stage_i_ds: self.stage_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_stage_i_ds(self): if hasattr(self, '_m_has_field_stage_i_ds'): return self._m_has_field_stage_i_ds self._m_has_field_stage_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stage_i_ds', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ActivityPotionBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBornType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigBornBySelectedPoint(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigBornByTeleportToPoint(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigBornByFollowEffectOverPos(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigBornType(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigBornByAttachPoint(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigBornByWorld(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigBornByGlobalValue(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBornByTarget(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigBornByElementPos(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigBornByPredicatePoint(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigBornByHitPoint(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigBornBySelfOwner(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigBornByStormLightning(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigBornByActionPoint(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigBornByCollisionPoint(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigBornByRushToPoint(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigBornByTargetLinearPoint(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBornBySelf(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class MatchLimitExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfMatchCondLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond', None) class CityConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LuminanceStoneChallengeOverallExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_final_stage_id: self.final_stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_final_gallery_id: self.final_gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_parent_quest_id_list: self.parent_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_rule_desc: self.gallery_rule_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_parent_quest_id_list(self): if hasattr(self, '_m_has_field_parent_quest_id_list'): return self._m_has_field_parent_quest_id_list self._m_has_field_parent_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_parent_quest_id_list', None) @property def has_field_final_gallery_id(self): if hasattr(self, '_m_has_field_final_gallery_id'): return self._m_has_field_final_gallery_id self._m_has_field_final_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_final_gallery_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_final_stage_id(self): if hasattr(self, '_m_has_field_final_stage_id'): return self._m_has_field_final_stage_id self._m_has_field_final_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_final_stage_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_gallery_rule_desc(self): if hasattr(self, '_m_has_field_gallery_rule_desc'): return self._m_has_field_gallery_rule_desc self._m_has_field_gallery_rule_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_gallery_rule_desc', None) class KvpOfDictAuxTypesStringConfigAiSensingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAiSensingSetting(self._io, self, self._root) class EnumKillSelfType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.KillSelfType, self.data.value) return getattr(self, '_m_value', None) class DungeonList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_list: self.dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_dungeon_list(self): if hasattr(self, '_m_has_field_dungeon_list'): return self._m_has_field_dungeon_list self._m_has_field_dungeon_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_list', None) class ConfigAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_mixins: self.ability_mixins = Output.ArrayOfDispConfigAbilityMixinLengthU(self._io, self, self._root) if self.has_field_ability_specials: self.ability_specials = Output.DictOfAuxTypesStringAuxTypesDynamicArgument(self._io, self, self._root) if self.has_field_modifiers: self.modifiers = Output.DictOfAuxTypesStringConfigAbilityModifier(self._io, self, self._root) if self.has_field_default_modifier: self.default_modifier = Output.ConfigAbilityModifier(self._io, self, self._root) if self.has_field_on_added: self.on_added = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_removed: self.on_removed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_ability_start: self.on_ability_start = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_kill: self.on_kill = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_field_enter: self.on_field_enter = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_field_exit: self.on_field_exit = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_attach: self.on_attach = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_detach: self.on_detach = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_avatar_in: self.on_avatar_in = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_avatar_out: self.on_avatar_out = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_vehicle_in: self.on_vehicle_in = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_vehicle_out: self.on_vehicle_out = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_trigger_avatar_ray: self.on_trigger_avatar_ray = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_zone_enter: self.on_zone_enter = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_zone_exit: self.on_zone_exit = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_is_dynamic_ability: self.is_dynamic_ability = self._io.read_u1() if self.has_field_ability_defined_properties: self.ability_defined_properties = Output.DictOfAuxTypesStringConfigAbilityPropertyEntry(self._io, self, self._root) @property def has_field_on_vehicle_out(self): if hasattr(self, '_m_has_field_on_vehicle_out'): return self._m_has_field_on_vehicle_out self._m_has_field_on_vehicle_out = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_on_vehicle_out', None) @property def has_field_on_trigger_avatar_ray(self): if hasattr(self, '_m_has_field_on_trigger_avatar_ray'): return self._m_has_field_on_trigger_avatar_ray self._m_has_field_on_trigger_avatar_ray = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_on_trigger_avatar_ray', None) @property def has_field_on_vehicle_in(self): if hasattr(self, '_m_has_field_on_vehicle_in'): return self._m_has_field_on_vehicle_in self._m_has_field_on_vehicle_in = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_on_vehicle_in', None) @property def has_field_on_avatar_out(self): if hasattr(self, '_m_has_field_on_avatar_out'): return self._m_has_field_on_avatar_out self._m_has_field_on_avatar_out = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_on_avatar_out', None) @property def has_field_on_attach(self): if hasattr(self, '_m_has_field_on_attach'): return self._m_has_field_on_attach self._m_has_field_on_attach = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_on_attach', None) @property def has_field_on_zone_enter(self): if hasattr(self, '_m_has_field_on_zone_enter'): return self._m_has_field_on_zone_enter self._m_has_field_on_zone_enter = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_on_zone_enter', None) @property def has_field_on_ability_start(self): if hasattr(self, '_m_has_field_on_ability_start'): return self._m_has_field_on_ability_start self._m_has_field_on_ability_start = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_ability_start', None) @property def has_field_ability_mixins(self): if hasattr(self, '_m_has_field_ability_mixins'): return self._m_has_field_ability_mixins self._m_has_field_ability_mixins = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_ability_mixins', None) @property def has_field_on_field_enter(self): if hasattr(self, '_m_has_field_on_field_enter'): return self._m_has_field_on_field_enter self._m_has_field_on_field_enter = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_on_field_enter', None) @property def has_field_modifiers(self): if hasattr(self, '_m_has_field_modifiers'): return self._m_has_field_modifiers self._m_has_field_modifiers = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_modifiers', None) @property def has_field_default_modifier(self): if hasattr(self, '_m_has_field_default_modifier'): return self._m_has_field_default_modifier self._m_has_field_default_modifier = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_default_modifier', None) @property def has_field_on_added(self): if hasattr(self, '_m_has_field_on_added'): return self._m_has_field_on_added self._m_has_field_on_added = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_on_added', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_ability_defined_properties(self): if hasattr(self, '_m_has_field_ability_defined_properties'): return self._m_has_field_ability_defined_properties self._m_has_field_ability_defined_properties = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_ability_defined_properties', None) @property def has_field_on_removed(self): if hasattr(self, '_m_has_field_on_removed'): return self._m_has_field_on_removed self._m_has_field_on_removed = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_removed', None) @property def has_field_on_field_exit(self): if hasattr(self, '_m_has_field_on_field_exit'): return self._m_has_field_on_field_exit self._m_has_field_on_field_exit = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_on_field_exit', None) @property def has_field_on_kill(self): if hasattr(self, '_m_has_field_on_kill'): return self._m_has_field_on_kill self._m_has_field_on_kill = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_on_kill', None) @property def has_field_on_zone_exit(self): if hasattr(self, '_m_has_field_on_zone_exit'): return self._m_has_field_on_zone_exit self._m_has_field_on_zone_exit = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_on_zone_exit', None) @property def has_field_on_avatar_in(self): if hasattr(self, '_m_has_field_on_avatar_in'): return self._m_has_field_on_avatar_in self._m_has_field_on_avatar_in = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_on_avatar_in', None) @property def has_field_is_dynamic_ability(self): if hasattr(self, '_m_has_field_is_dynamic_ability'): return self._m_has_field_is_dynamic_ability self._m_has_field_is_dynamic_ability = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_is_dynamic_ability', None) @property def has_field_on_detach(self): if hasattr(self, '_m_has_field_on_detach'): return self._m_has_field_on_detach self._m_has_field_on_detach = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_on_detach', None) @property def has_field_ability_specials(self): if hasattr(self, '_m_has_field_ability_specials'): return self._m_has_field_ability_specials self._m_has_field_ability_specials = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_ability_specials', None) class EFootprintPlatformComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAitsTargetDistanceSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiThreatScoreBaseSetting(self._io, self, self._root) @property def max(self): if hasattr(self, '_m_max'): return self._m_max self._m_max = self.base.max return getattr(self, '_m_max', None) @property def min(self): if hasattr(self, '_m_min'): return self._m_min self._m_min = self.base.min return getattr(self, '_m_min', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def compare_operation(self): if hasattr(self, '_m_compare_operation'): return self._m_compare_operation self._m_compare_operation = self.base.compare_operation return getattr(self, '_m_compare_operation', None) @property def weight(self): if hasattr(self, '_m_weight'): return self._m_weight self._m_weight = self.base.weight return getattr(self, '_m_weight', None) class ArrayOfConfigWaypointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigWaypoint(self._io, self, self._root)) class EnumCompoundType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CompoundType, self.data.value) return getattr(self, '_m_value', None) class ActivitySumoStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAnimationCurve(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_keyframes: self.keyframes = Output.ArrayOfConfigKeyframeLengthU(self._io, self, self._root) @property def has_field_keyframes(self): if hasattr(self, '_m_has_field_keyframes'): return self._m_has_field_keyframes self._m_has_field_keyframes = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_keyframes', None) class DictOfAuxTypesStringArrayOfDispConfigAudioEventCullingRuleBaseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfDispConfigAudioEventCullingRuleBaseLengthU(self._io, self, self._root)) class ConfigAiSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_start_distance: self.start_distance = self._io.read_f4le() if self.has_field_surround_radius: self.surround_radius = self._io.read_f4le() if self.has_field_turning_states: self.turning_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_detect_front_distance: self.detect_front_distance = self._io.read_f4le() if self.has_field_detect_front_offset_up: self.detect_front_offset_up = self._io.read_f4le() if self.has_field_detect_front_offset_forward: self.detect_front_offset_forward = self._io.read_f4le() @property def has_field_detect_front_offset_up(self): if hasattr(self, '_m_has_field_detect_front_offset_up'): return self._m_has_field_detect_front_offset_up self._m_has_field_detect_front_offset_up = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_detect_front_offset_up', None) @property def has_field_detect_front_offset_forward(self): if hasattr(self, '_m_has_field_detect_front_offset_forward'): return self._m_has_field_detect_front_offset_forward self._m_has_field_detect_front_offset_forward = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_detect_front_offset_forward', None) @property def has_field_turning_states(self): if hasattr(self, '_m_has_field_turning_states'): return self._m_has_field_turning_states self._m_has_field_turning_states = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_turning_states', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_surround_radius(self): if hasattr(self, '_m_has_field_surround_radius'): return self._m_has_field_surround_radius self._m_has_field_surround_radius = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_surround_radius', None) @property def has_field_start_distance(self): if hasattr(self, '_m_has_field_start_distance'): return self._m_has_field_start_distance self._m_has_field_start_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_start_distance', None) @property def has_field_detect_front_distance(self): if hasattr(self, '_m_has_field_detect_front_distance'): return self._m_has_field_detect_front_distance self._m_has_field_detect_front_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_detect_front_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class GroupEntityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPlayerDieType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlayerDieType, self.data.value) return getattr(self, '_m_value', None) class EnumDieFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DieFlag, self.data.value) return getattr(self, '_m_value', None) class OpenStateConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_default_state: self.default_state = self._io.read_u1() if self.has_field_allow_client_open: self.allow_client_open = self._io.read_u1() if self.has_field_cond: self.cond = Output.ArrayOfOpenStateCondLengthS(self._io, self, self._root) if self.has_field_system_open_ui_id: self.system_open_ui_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_system_open_ui_id(self): if hasattr(self, '_m_has_field_system_open_ui_id'): return self._m_has_field_system_open_ui_id self._m_has_field_system_open_ui_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_system_open_ui_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_default_state(self): if hasattr(self, '_m_has_field_default_state'): return self._m_has_field_default_state self._m_has_field_default_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_default_state', None) @property def has_field_allow_client_open(self): if hasattr(self, '_m_has_field_allow_client_open'): return self._m_has_field_allow_client_open self._m_has_field_allow_client_open = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_allow_client_open', None) class OfferingActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFreeDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class EnumRouteType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RouteType, self.data.value) return getattr(self, '_m_value', None) class ActivityPotionModeChoiceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mode_id: self.mode_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_ratio: self.score_ratio = self._io.read_f4le() if self.has_field_dungeon_level: self.dungeon_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_mode_id(self): if hasattr(self, '_m_has_field_mode_id'): return self._m_has_field_mode_id self._m_has_field_mode_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mode_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_score_ratio(self): if hasattr(self, '_m_has_field_score_ratio'): return self._m_has_field_score_ratio self._m_has_field_score_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_score_ratio', None) @property def has_field_dungeon_level(self): if hasattr(self, '_m_has_field_dungeon_level'): return self._m_has_field_dungeon_level self._m_has_field_dungeon_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_level', None) class ConfigWidgetToyBlessingCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_fixed: self.is_fixed = self._io.read_u1() @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_is_fixed(self): if hasattr(self, '_m_has_field_is_fixed'): return self._m_has_field_is_fixed self._m_has_field_is_fixed = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_fixed', None) class KvpOfDictAuxTypesStringFaceAnimationTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.FaceAnimationTypeConfig(self._io, self, self._root) class ConfigLinerBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ScanAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSimpleBlackScreenAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration_to_black: self.duration_to_black = self._io.read_f4le() if self.has_field_duration_keep_black: self.duration_keep_black = self._io.read_f4le() if self.has_field_duration_from_black: self.duration_from_black = self._io.read_f4le() if self.has_field_text_map_id: self.text_map_id = AuxTypes.String(self._io, self, self._root) if self.has_field_use_white_screen: self.use_white_screen = self._io.read_u1() if self.has_field_use_text_fade: self.use_text_fade = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_disable_res_async_load: self.disable_res_async_load = self._io.read_u1() @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_text_map_id(self): if hasattr(self, '_m_has_field_text_map_id'): return self._m_has_field_text_map_id self._m_has_field_text_map_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_text_map_id', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_duration_from_black(self): if hasattr(self, '_m_has_field_duration_from_black'): return self._m_has_field_duration_from_black self._m_has_field_duration_from_black = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration_from_black', None) @property def has_field_duration_keep_black(self): if hasattr(self, '_m_has_field_duration_keep_black'): return self._m_has_field_duration_keep_black self._m_has_field_duration_keep_black = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration_keep_black', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_use_text_fade(self): if hasattr(self, '_m_has_field_use_text_fade'): return self._m_has_field_use_text_fade self._m_has_field_use_text_fade = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_use_text_fade', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_use_white_screen(self): if hasattr(self, '_m_has_field_use_white_screen'): return self._m_has_field_use_white_screen self._m_has_field_use_white_screen = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_white_screen', None) @property def has_field_disable_res_async_load(self): if hasattr(self, '_m_has_field_disable_res_async_load'): return self._m_has_field_disable_res_async_load self._m_has_field_disable_res_async_load = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_disable_res_async_load', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_duration_to_black(self): if hasattr(self, '_m_has_field_duration_to_black'): return self._m_has_field_duration_to_black self._m_has_field_duration_to_black = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration_to_black', None) class EnumIrodoriChessCardTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardTargetType, self.data.value) return getattr(self, '_m_value', None) class ProudSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumShopRefreshType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopRefreshType, self.data.value) return getattr(self, '_m_value', None) class PersonalSceneJumpPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tran_scene_id: self.tran_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_text_id: self.title_text_id = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_size: self.trigger_size = Output.Vector(self._io, self, self._root) if self.has_field_open_time: self.open_time = self._io.read_f4le() if self.has_field_close_time: self.close_time = self._io.read_f4le() if self.has_field_is_homeworld_door: self.is_homeworld_door = self._io.read_u1() @property def has_field_title_text_id(self): if hasattr(self, '_m_has_field_title_text_id'): return self._m_has_field_title_text_id self._m_has_field_title_text_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_title_text_id', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_close_time(self): if hasattr(self, '_m_has_field_close_time'): return self._m_has_field_close_time self._m_has_field_close_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_close_time', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_open_time(self): if hasattr(self, '_m_has_field_open_time'): return self._m_has_field_open_time self._m_has_field_open_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_open_time', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_tran_scene_id(self): if hasattr(self, '_m_has_field_tran_scene_id'): return self._m_has_field_tran_scene_id self._m_has_field_tran_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tran_scene_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_trigger_size(self): if hasattr(self, '_m_has_field_trigger_size'): return self._m_has_field_trigger_size self._m_has_field_trigger_size = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trigger_size', None) @property def has_field_is_homeworld_door(self): if hasattr(self, '_m_has_field_is_homeworld_door'): return self._m_has_field_is_homeworld_door self._m_has_field_is_homeworld_door = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_is_homeworld_door', None) class AudioStateOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_group: self.group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_value: self.value = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_group(self): if hasattr(self, '_m_has_field_group'): return self._m_has_field_group self._m_has_field_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class SelectActionPointByTargetPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class EnumIrodoriChessCardEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardEffectType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiSpacialChaseSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSpacialChaseData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSpacialChaseData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class AttackByEnergy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_energy: self.energy = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_over_damage_ratio: self.over_damage_ratio = self._io.read_f4le() if self.has_field_over_damage_max_hp_ratio: self.over_damage_max_hp_ratio = self._io.read_f4le() @property def has_field_over_damage_max_hp_ratio(self): if hasattr(self, '_m_has_field_over_damage_max_hp_ratio'): return self._m_has_field_over_damage_max_hp_ratio self._m_has_field_over_damage_max_hp_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_over_damage_max_hp_ratio', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_over_damage_ratio(self): if hasattr(self, '_m_has_field_over_damage_ratio'): return self._m_has_field_over_damage_ratio self._m_has_field_over_damage_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_over_damage_ratio', None) @property def has_field_energy(self): if hasattr(self, '_m_has_field_energy'): return self._m_has_field_energy self._m_has_field_energy = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_energy', None) class DictOfAuxTypesVlqBase128LeSConfigAiPatrolFollowData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiPatrolFollowData(self._io, self, self._root)) class TreeDropExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopmallRecommendConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_tab_id: self.sub_tab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab_type: self.tab_type = Output.EnumShopRecommendTabType(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) if self.has_field_goods_id_vec: self.goods_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_config_id_vec: self.config_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_vec: self.cond_vec = Output.ArrayOfShopmallRecommendCondLengthS(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_type: self.tag_type = Output.EnumShopRecommendTagType(self._io, self, self._root) if self.has_field_one_card_icon_name: self.one_card_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_col_show_icon_name: self.col_show_icon_name = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_jump_entrance_id: self.jump_entrance_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_sale_remain_time: self.show_sale_remain_time = self._io.read_u1() @property def has_field_one_card_icon_name(self): if hasattr(self, '_m_has_field_one_card_icon_name'): return self._m_has_field_one_card_icon_name self._m_has_field_one_card_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_one_card_icon_name', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_goods_id_vec(self): if hasattr(self, '_m_has_field_goods_id_vec'): return self._m_has_field_goods_id_vec self._m_has_field_goods_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_goods_id_vec', None) @property def has_field_col_show_icon_name(self): if hasattr(self, '_m_has_field_col_show_icon_name'): return self._m_has_field_col_show_icon_name self._m_has_field_col_show_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_col_show_icon_name', None) @property def has_field_cond_vec(self): if hasattr(self, '_m_has_field_cond_vec'): return self._m_has_field_cond_vec self._m_has_field_cond_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cond_vec', None) @property def has_field_show_sale_remain_time(self): if hasattr(self, '_m_has_field_show_sale_remain_time'): return self._m_has_field_show_sale_remain_time self._m_has_field_show_sale_remain_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_show_sale_remain_time', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_tag_type(self): if hasattr(self, '_m_has_field_tag_type'): return self._m_has_field_tag_type self._m_has_field_tag_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_tag_type', None) @property def has_field_jump_entrance_id(self): if hasattr(self, '_m_has_field_jump_entrance_id'): return self._m_has_field_jump_entrance_id self._m_has_field_jump_entrance_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_jump_entrance_id', None) @property def has_field_tab_type(self): if hasattr(self, '_m_has_field_tab_type'): return self._m_has_field_tab_type self._m_has_field_tab_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tab_type', None) @property def has_field_sub_tab_id(self): if hasattr(self, '_m_has_field_sub_tab_id'): return self._m_has_field_sub_tab_id self._m_has_field_sub_tab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_tab_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_config_id_vec(self): if hasattr(self, '_m_has_field_config_id_vec'): return self._m_has_field_config_id_vec self._m_has_field_config_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_config_id_vec', None) class DictOfAuxTypesVlqBase128LeSArrayOfEquipSizeDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSArrayOfEquipSizeDataLengthU(self._io, self, self._root)) class PushTipsCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DailyTaskActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCameraSplineCatmullPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBasePoint(self._io, self, self._root) @property def t_list(self): if hasattr(self, '_m_t_list'): return self._m_t_list self._m_t_list = self.base.t_list return getattr(self, '_m_t_list', None) @property def position(self): if hasattr(self, '_m_position'): return self._m_position self._m_position = self.base.position return getattr(self, '_m_position', None) @property def dutch(self): if hasattr(self, '_m_dutch'): return self._m_dutch self._m_dutch = self.base.dutch return getattr(self, '_m_dutch', None) @property def euler_angle(self): if hasattr(self, '_m_euler_angle'): return self._m_euler_angle self._m_euler_angle = self.base.euler_angle return getattr(self, '_m_euler_angle', None) @property def s_list(self): if hasattr(self, '_m_s_list'): return self._m_s_list self._m_s_list = self.base.s_list return getattr(self, '_m_s_list', None) @property def length_ratio(self): if hasattr(self, '_m_length_ratio'): return self._m_length_ratio self._m_length_ratio = self.base.length_ratio return getattr(self, '_m_length_ratio', None) class CustomGadgetSlotLevelTagConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_custom_gadget_type: self.custom_gadget_type = Output.EnumCustomGadgetRootType(self._io, self, self._root) if self.has_field_slot_map: self.slot_map = Output.ArrayOfCustomGadgetSlotGroupLengthS(self._io, self, self._root) if self.has_field_level_tag_id: self.level_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_custom_gadget_type(self): if hasattr(self, '_m_has_field_custom_gadget_type'): return self._m_has_field_custom_gadget_type self._m_has_field_custom_gadget_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_custom_gadget_type', None) @property def has_field_level_tag_id(self): if hasattr(self, '_m_has_field_level_tag_id'): return self._m_has_field_level_tag_id self._m_has_field_level_tag_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_tag_id', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_slot_map(self): if hasattr(self, '_m_has_field_slot_map'): return self._m_has_field_slot_map self._m_has_field_slot_map = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_slot_map', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class WeaponLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root)) class MoveStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumMoveStateMixinType(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAbilityModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_scale: self.time_scale = Output.EnumModifierTimeScale(self._io, self, self._root) if self.has_field_stacking: self.stacking = Output.EnumModifierStacking(self._io, self, self._root) if self.has_field_stacking_option: self.stacking_option = Output.ConfigModifierStackingOption(self._io, self, self._root) if self.has_field_is_buff: self.is_buff = self._io.read_u1() if self.has_field_is_debuff: self.is_debuff = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_unique: self.is_unique = self._io.read_u1() if self.has_field_duration: self.duration = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_element_durability: self.element_durability = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_element_durability: self.max_element_durability = self._io.read_f4le() if self.has_field_purge_increment: self.purge_increment = self._io.read_f4le() if self.has_field_is_element_durability_mutable: self.is_element_durability_mutable = self._io.read_u1() if self.has_field_force_trigger_burning: self.force_trigger_burning = self._io.read_u1() if self.has_field_override_weapon_element: self.override_weapon_element = self._io.read_u1() if self.has_field_think_interval: self.think_interval = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_modifier_mixins: self.modifier_mixins = Output.ArrayOfDispConfigAbilityMixinLengthU(self._io, self, self._root) if self.has_field_trim_think_interval: self.trim_think_interval = self._io.read_u1() if self.has_field_properties: self.properties = Output.DictOfAuxTypesStringAuxTypesDynamicFloat(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumAbilityState(self._io, self, self._root) if self.has_field_state_option: self.state_option = Output.ConfigAbilityStateOption(self._io, self, self._root) if self.has_field_mute_state_display_effect: self.mute_state_display_effect = self._io.read_u1() if self.has_field_apply_attacker_witch_time_ratio: self.apply_attacker_witch_time_ratio = self._io.read_u1() if self.has_field_on_added: self.on_added = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_removed: self.on_removed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_being_hit: self.on_being_hit = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_attack_landed: self.on_attack_landed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_hitting_other: self.on_hitting_other = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_heal: self.on_heal = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_being_healed: self.on_being_healed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_think_interval: self.on_think_interval = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_think_interval_is_fixed_update: self.on_think_interval_is_fixed_update = self._io.read_u1() if self.has_field_on_kill: self.on_kill = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_crash: self.on_crash = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_avatar_in: self.on_avatar_in = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_avatar_out: self.on_avatar_out = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_vehicle_in: self.on_vehicle_in = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_vehicle_out: self.on_vehicle_out = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_zone_enter: self.on_zone_enter = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_zone_exit: self.on_zone_exit = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_reconnect: self.on_reconnect = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_change_authority: self.on_change_authority = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_forbidden_entities: self.forbidden_entities = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_fire_event_when_apply: self.fire_event_when_apply = self._io.read_u1() if self.has_field_is_durability_global: self.is_durability_global = self._io.read_u1() if self.has_field_tick_think_interval_after_die: self.tick_think_interval_after_die = self._io.read_u1() if self.has_field_think_interval_ignore_time_scale: self.think_interval_ignore_time_scale = self._io.read_u1() if self.has_field_reduce_durablity_ignore_time_scale: self.reduce_durablity_ignore_time_scale = self._io.read_u1() if self.has_field_is_limited_properties: self.is_limited_properties = self._io.read_u1() if self.has_field_force_sync_to_remote: self.force_sync_to_remote = self._io.read_u1() if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_retain_when_durability_is_zero: self.retain_when_durability_is_zero = self._io.read_u1() if self.has_field_modifier_tags: self.modifier_tags = Output.ArrayOfEnumModifierTagLengthU(self._io, self, self._root) if self.has_field_use_dummy_ability: self.use_dummy_ability = self._io.read_u1() if self.has_field_dummy_ability_option: self.dummy_ability_option = Output.ConfigDummyAbilityOption(self._io, self, self._root) @property def has_field_retain_when_durability_is_zero(self): if hasattr(self, '_m_has_field_retain_when_durability_is_zero'): return self._m_has_field_retain_when_durability_is_zero self._m_has_field_retain_when_durability_is_zero = (self.bit_field.value & 2251799813685248) != 0 return getattr(self, '_m_has_field_retain_when_durability_is_zero', None) @property def has_field_on_vehicle_out(self): if hasattr(self, '_m_has_field_on_vehicle_out'): return self._m_has_field_on_vehicle_out self._m_has_field_on_vehicle_out = (self.bit_field.value & 137438953472) != 0 return getattr(self, '_m_has_field_on_vehicle_out', None) @property def has_field_is_durability_global(self): if hasattr(self, '_m_has_field_is_durability_global'): return self._m_has_field_is_durability_global self._m_has_field_is_durability_global = (self.bit_field.value & 17592186044416) != 0 return getattr(self, '_m_has_field_is_durability_global', None) @property def has_field_purge_increment(self): if hasattr(self, '_m_has_field_purge_increment'): return self._m_has_field_purge_increment self._m_has_field_purge_increment = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_purge_increment', None) @property def has_field_on_vehicle_in(self): if hasattr(self, '_m_has_field_on_vehicle_in'): return self._m_has_field_on_vehicle_in self._m_has_field_on_vehicle_in = (self.bit_field.value & 68719476736) != 0 return getattr(self, '_m_has_field_on_vehicle_in', None) @property def has_field_on_avatar_out(self): if hasattr(self, '_m_has_field_on_avatar_out'): return self._m_has_field_on_avatar_out self._m_has_field_on_avatar_out = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_on_avatar_out', None) @property def has_field_on_think_interval_is_fixed_update(self): if hasattr(self, '_m_has_field_on_think_interval_is_fixed_update'): return self._m_has_field_on_think_interval_is_fixed_update self._m_has_field_on_think_interval_is_fixed_update = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_on_think_interval_is_fixed_update', None) @property def has_field_force_sync_to_remote(self): if hasattr(self, '_m_has_field_force_sync_to_remote'): return self._m_has_field_force_sync_to_remote self._m_has_field_force_sync_to_remote = (self.bit_field.value & 562949953421312) != 0 return getattr(self, '_m_has_field_force_sync_to_remote', None) @property def has_field_fire_event_when_apply(self): if hasattr(self, '_m_has_field_fire_event_when_apply'): return self._m_has_field_fire_event_when_apply self._m_has_field_fire_event_when_apply = (self.bit_field.value & 8796093022208) != 0 return getattr(self, '_m_has_field_fire_event_when_apply', None) @property def has_field_stacking_option(self): if hasattr(self, '_m_has_field_stacking_option'): return self._m_has_field_stacking_option self._m_has_field_stacking_option = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_stacking_option', None) @property def has_field_is_element_durability_mutable(self): if hasattr(self, '_m_has_field_is_element_durability_mutable'): return self._m_has_field_is_element_durability_mutable self._m_has_field_is_element_durability_mutable = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_is_element_durability_mutable', None) @property def has_field_on_being_hit(self): if hasattr(self, '_m_has_field_on_being_hit'): return self._m_has_field_on_being_hit self._m_has_field_on_being_hit = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_on_being_hit', None) @property def has_field_on_zone_enter(self): if hasattr(self, '_m_has_field_on_zone_enter'): return self._m_has_field_on_zone_enter self._m_has_field_on_zone_enter = (self.bit_field.value & 274877906944) != 0 return getattr(self, '_m_has_field_on_zone_enter', None) @property def has_field_properties(self): if hasattr(self, '_m_has_field_properties'): return self._m_has_field_properties self._m_has_field_properties = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_properties', None) @property def has_field_is_buff(self): if hasattr(self, '_m_has_field_is_buff'): return self._m_has_field_is_buff self._m_has_field_is_buff = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_is_buff', None) @property def has_field_on_heal(self): if hasattr(self, '_m_has_field_on_heal'): return self._m_has_field_on_heal self._m_has_field_on_heal = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_on_heal', None) @property def has_field_on_crash(self): if hasattr(self, '_m_has_field_on_crash'): return self._m_has_field_on_crash self._m_has_field_on_crash = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_on_crash', None) @property def has_field_on_being_healed(self): if hasattr(self, '_m_has_field_on_being_healed'): return self._m_has_field_on_being_healed self._m_has_field_on_being_healed = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_on_being_healed', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_state', None) @property def has_field_is_debuff(self): if hasattr(self, '_m_has_field_is_debuff'): return self._m_has_field_is_debuff self._m_has_field_is_debuff = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_is_debuff', None) @property def has_field_force_trigger_burning(self): if hasattr(self, '_m_has_field_force_trigger_burning'): return self._m_has_field_force_trigger_burning self._m_has_field_force_trigger_burning = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_force_trigger_burning', None) @property def has_field_on_attack_landed(self): if hasattr(self, '_m_has_field_on_attack_landed'): return self._m_has_field_on_attack_landed self._m_has_field_on_attack_landed = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_on_attack_landed', None) @property def has_field_on_added(self): if hasattr(self, '_m_has_field_on_added'): return self._m_has_field_on_added self._m_has_field_on_added = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_on_added', None) @property def has_field_trim_think_interval(self): if hasattr(self, '_m_has_field_trim_think_interval'): return self._m_has_field_trim_think_interval self._m_has_field_trim_think_interval = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_trim_think_interval', None) @property def has_field_modifier_mixins(self): if hasattr(self, '_m_has_field_modifier_mixins'): return self._m_has_field_modifier_mixins self._m_has_field_modifier_mixins = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_modifier_mixins', None) @property def has_field_on_change_authority(self): if hasattr(self, '_m_has_field_on_change_authority'): return self._m_has_field_on_change_authority self._m_has_field_on_change_authority = (self.bit_field.value & 2199023255552) != 0 return getattr(self, '_m_has_field_on_change_authority', None) @property def has_field_max_element_durability(self): if hasattr(self, '_m_has_field_max_element_durability'): return self._m_has_field_max_element_durability self._m_has_field_max_element_durability = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_max_element_durability', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = (self.bit_field.value & 1125899906842624) != 0 return getattr(self, '_m_has_field_buff_id', None) @property def has_field_is_unique(self): if hasattr(self, '_m_has_field_is_unique'): return self._m_has_field_is_unique self._m_has_field_is_unique = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_is_unique', None) @property def has_field_state_option(self): if hasattr(self, '_m_has_field_state_option'): return self._m_has_field_state_option self._m_has_field_state_option = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_state_option', None) @property def has_field_on_removed(self): if hasattr(self, '_m_has_field_on_removed'): return self._m_has_field_on_removed self._m_has_field_on_removed = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_on_removed', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_reduce_durablity_ignore_time_scale(self): if hasattr(self, '_m_has_field_reduce_durablity_ignore_time_scale'): return self._m_has_field_reduce_durablity_ignore_time_scale self._m_has_field_reduce_durablity_ignore_time_scale = (self.bit_field.value & 140737488355328) != 0 return getattr(self, '_m_has_field_reduce_durablity_ignore_time_scale', None) @property def has_field_stacking(self): if hasattr(self, '_m_has_field_stacking'): return self._m_has_field_stacking self._m_has_field_stacking = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_stacking', None) @property def has_field_on_think_interval(self): if hasattr(self, '_m_has_field_on_think_interval'): return self._m_has_field_on_think_interval self._m_has_field_on_think_interval = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_on_think_interval', None) @property def has_field_on_kill(self): if hasattr(self, '_m_has_field_on_kill'): return self._m_has_field_on_kill self._m_has_field_on_kill = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_on_kill', None) @property def has_field_on_zone_exit(self): if hasattr(self, '_m_has_field_on_zone_exit'): return self._m_has_field_on_zone_exit self._m_has_field_on_zone_exit = (self.bit_field.value & 549755813888) != 0 return getattr(self, '_m_has_field_on_zone_exit', None) @property def has_field_dummy_ability_option(self): if hasattr(self, '_m_has_field_dummy_ability_option'): return self._m_has_field_dummy_ability_option self._m_has_field_dummy_ability_option = (self.bit_field.value & 18014398509481984) != 0 return getattr(self, '_m_has_field_dummy_ability_option', None) @property def has_field_forbidden_entities(self): if hasattr(self, '_m_has_field_forbidden_entities'): return self._m_has_field_forbidden_entities self._m_has_field_forbidden_entities = (self.bit_field.value & 4398046511104) != 0 return getattr(self, '_m_has_field_forbidden_entities', None) @property def has_field_time_scale(self): if hasattr(self, '_m_has_field_time_scale'): return self._m_has_field_time_scale self._m_has_field_time_scale = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_time_scale', None) @property def has_field_on_avatar_in(self): if hasattr(self, '_m_has_field_on_avatar_in'): return self._m_has_field_on_avatar_in self._m_has_field_on_avatar_in = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_on_avatar_in', None) @property def has_field_tick_think_interval_after_die(self): if hasattr(self, '_m_has_field_tick_think_interval_after_die'): return self._m_has_field_tick_think_interval_after_die self._m_has_field_tick_think_interval_after_die = (self.bit_field.value & 35184372088832) != 0 return getattr(self, '_m_has_field_tick_think_interval_after_die', None) @property def has_field_on_hitting_other(self): if hasattr(self, '_m_has_field_on_hitting_other'): return self._m_has_field_on_hitting_other self._m_has_field_on_hitting_other = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_on_hitting_other', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_element_durability(self): if hasattr(self, '_m_has_field_element_durability'): return self._m_has_field_element_durability self._m_has_field_element_durability = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_element_durability', None) @property def has_field_modifier_tags(self): if hasattr(self, '_m_has_field_modifier_tags'): return self._m_has_field_modifier_tags self._m_has_field_modifier_tags = (self.bit_field.value & 4503599627370496) != 0 return getattr(self, '_m_has_field_modifier_tags', None) @property def has_field_on_reconnect(self): if hasattr(self, '_m_has_field_on_reconnect'): return self._m_has_field_on_reconnect self._m_has_field_on_reconnect = (self.bit_field.value & 1099511627776) != 0 return getattr(self, '_m_has_field_on_reconnect', None) @property def has_field_override_weapon_element(self): if hasattr(self, '_m_has_field_override_weapon_element'): return self._m_has_field_override_weapon_element self._m_has_field_override_weapon_element = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_override_weapon_element', None) @property def has_field_apply_attacker_witch_time_ratio(self): if hasattr(self, '_m_has_field_apply_attacker_witch_time_ratio'): return self._m_has_field_apply_attacker_witch_time_ratio self._m_has_field_apply_attacker_witch_time_ratio = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_apply_attacker_witch_time_ratio', None) @property def has_field_mute_state_display_effect(self): if hasattr(self, '_m_has_field_mute_state_display_effect'): return self._m_has_field_mute_state_display_effect self._m_has_field_mute_state_display_effect = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_mute_state_display_effect', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_think_interval(self): if hasattr(self, '_m_has_field_think_interval'): return self._m_has_field_think_interval self._m_has_field_think_interval = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_think_interval', None) @property def has_field_use_dummy_ability(self): if hasattr(self, '_m_has_field_use_dummy_ability'): return self._m_has_field_use_dummy_ability self._m_has_field_use_dummy_ability = (self.bit_field.value & 9007199254740992) != 0 return getattr(self, '_m_has_field_use_dummy_ability', None) @property def has_field_is_limited_properties(self): if hasattr(self, '_m_has_field_is_limited_properties'): return self._m_has_field_is_limited_properties self._m_has_field_is_limited_properties = (self.bit_field.value & 281474976710656) != 0 return getattr(self, '_m_has_field_is_limited_properties', None) @property def has_field_think_interval_ignore_time_scale(self): if hasattr(self, '_m_has_field_think_interval_ignore_time_scale'): return self._m_has_field_think_interval_ignore_time_scale self._m_has_field_think_interval_ignore_time_scale = (self.bit_field.value & 70368744177664) != 0 return getattr(self, '_m_has_field_think_interval_ignore_time_scale', None) class ReputationQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigNpcBornPosLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigNpcBornPos(self._io, self, self._root)) class MichiaeErosionMapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_erosion_range: self.erosion_range = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_erosion_desc: self.erosion_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_energy_desc: self.energy_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_erosion_range(self): if hasattr(self, '_m_has_field_erosion_range'): return self._m_has_field_erosion_range self._m_has_field_erosion_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_erosion_range', None) @property def has_field_erosion_desc(self): if hasattr(self, '_m_has_field_erosion_desc'): return self._m_has_field_erosion_desc self._m_has_field_erosion_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_erosion_desc', None) @property def has_field_energy_desc(self): if hasattr(self, '_m_has_field_energy_desc'): return self._m_has_field_energy_desc self._m_has_field_energy_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_energy_desc', None) class PlayerLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_max_exp: self.max_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_expedition_limit_add: self.expedition_limit_add = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_world_level: self.unlock_world_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_desc: self.unlock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_max_exp(self): if hasattr(self, '_m_has_field_max_exp'): return self._m_has_field_max_exp self._m_has_field_max_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_max_exp', None) @property def has_field_unlock_desc(self): if hasattr(self, '_m_has_field_unlock_desc'): return self._m_has_field_unlock_desc self._m_has_field_unlock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_desc', None) @property def has_field_unlock_world_level(self): if hasattr(self, '_m_has_field_unlock_world_level'): return self._m_has_field_unlock_world_level self._m_has_field_unlock_world_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_unlock_world_level', None) @property def has_field_expedition_limit_add(self): if hasattr(self, '_m_has_field_expedition_limit_add'): return self._m_has_field_expedition_limit_add self._m_has_field_expedition_limit_add = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_expedition_limit_add', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_exp', None) class SetSystemValueToOverrideMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumSystemValuerType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trans_radius: self.trans_radius = self._io.read_f4le() if self.has_field_points: self.points = Output.DictOfAuxTypesStringDispConfigScenePoint(self._io, self, self._root) if self.has_field_areas: self.areas = Output.DictOfAuxTypesStringConfigSceneArea(self._io, self, self._root) if self.has_field_forces: self.forces = Output.DictOfAuxTypesStringDispConfigScenePoint(self._io, self, self._root) if self.has_field_entities: self.entities = Output.DictOfAuxTypesStringDispConfigScenePoint(self._io, self, self._root) if self.has_field_doors: self.doors = Output.DictOfAuxTypesStringConfigLoadingDoor(self._io, self, self._root) @property def has_field_doors(self): if hasattr(self, '_m_has_field_doors'): return self._m_has_field_doors self._m_has_field_doors = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_doors', None) @property def has_field_points(self): if hasattr(self, '_m_has_field_points'): return self._m_has_field_points self._m_has_field_points = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_points', None) @property def has_field_entities(self): if hasattr(self, '_m_has_field_entities'): return self._m_has_field_entities self._m_has_field_entities = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_entities', None) @property def has_field_areas(self): if hasattr(self, '_m_has_field_areas'): return self._m_has_field_areas self._m_has_field_areas = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_areas', None) @property def has_field_forces(self): if hasattr(self, '_m_has_field_forces'): return self._m_has_field_forces self._m_has_field_forces = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_forces', None) @property def has_field_trans_radius(self): if hasattr(self, '_m_has_field_trans_radius'): return self._m_has_field_trans_radius self._m_has_field_trans_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trans_radius', None) class ConfigGuideShowTutorialAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tutorial_id', None) class ResetAvatarHitBuckets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigWindmill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLocalEntity(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def check_dist(self): if hasattr(self, '_m_check_dist'): return self._m_check_dist self._m_check_dist = self.base.check_dist return getattr(self, '_m_check_dist', None) @property def with_go(self): if hasattr(self, '_m_with_go'): return self._m_with_go self._m_with_go = self.base.with_go return getattr(self, '_m_with_go', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class EnumMaterialDestroyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MaterialDestroyType, self.data.value) return getattr(self, '_m_value', None) class GadgetInteractItemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMaterialExpireType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MaterialExpireType, self.data.value) return getattr(self, '_m_value', None) class ActivityChessPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WorldAreaLevelupConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_consume_item: self.consume_item = Output.WorldAreaLevelupConsumeItem(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_vec: self.action_vec = Output.ArrayOfWorldAreaLevelupActionLengthS(self._io, self, self._root) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_consume_item(self): if hasattr(self, '_m_has_field_consume_item'): return self._m_has_field_consume_item self._m_has_field_consume_item = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_consume_item', None) @property def has_field_action_vec(self): if hasattr(self, '_m_has_field_action_vec'): return self._m_has_field_action_vec self._m_has_field_action_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_action_vec', None) class DispConfigQteStepBaseAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigQteStepBaseAction(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigQteStepCutsceneJumpPointAction(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigQteStepCameraMoveAction(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigQteStepPowerBarAction(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigQteStepCutsceneFailedBlackScreenAction(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigQteStepBaseInterAction(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigQteStepPlayAudioAction(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigCodexQuestItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumCodexQuestItemType(self._io, self, self._root) if self.has_field_next_item_id: self.next_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speaker_text: self.speaker_text = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_speaker_text2: self.speaker_text2 = Output.ConfigCodexQuestText(self._io, self, self._root) if self.has_field_texts: self.texts = Output.ArrayOfConfigCodexQuestTextLengthU(self._io, self, self._root) if self.has_field_dialogs: self.dialogs = Output.ArrayOfConfigCodexQuestDialogSingleLengthU(self._io, self, self._root) if self.has_field_dialogs2: self.dialogs2 = Output.ArrayOfConfigCodexQuestDialogSingleLengthU(self._io, self, self._root) @property def has_field_dialogs(self): if hasattr(self, '_m_has_field_dialogs'): return self._m_has_field_dialogs self._m_has_field_dialogs = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_dialogs', None) @property def has_field_next_item_id(self): if hasattr(self, '_m_has_field_next_item_id'): return self._m_has_field_next_item_id self._m_has_field_next_item_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_next_item_id', None) @property def has_field_speaker_text2(self): if hasattr(self, '_m_has_field_speaker_text2'): return self._m_has_field_speaker_text2 self._m_has_field_speaker_text2 = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_speaker_text2', None) @property def has_field_texts(self): if hasattr(self, '_m_has_field_texts'): return self._m_has_field_texts self._m_has_field_texts = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_texts', None) @property def has_field_speaker_text(self): if hasattr(self, '_m_has_field_speaker_text'): return self._m_has_field_speaker_text self._m_has_field_speaker_text = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_speaker_text', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def has_field_dialogs2(self): if hasattr(self, '_m_has_field_dialogs2'): return self._m_has_field_dialogs2 self._m_has_field_dialogs2 = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_dialogs2', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_type', None) class AttachToAiAlertnessMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_alertness: self.alertness = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_alertness(self): if hasattr(self, '_m_has_field_alertness'): return self._m_has_field_alertness self._m_has_field_alertness = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_alertness', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicInt32noGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class KvpOfDictEnumElementTypeConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementType(self._io, self, self._root) self.value = Output.ConfigWwiseString(self._io, self, self._root) class ProductGoogleGiftCardDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PushTipsConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySummerTimeFloatSignalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mist_zone_id: self.mist_zone_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_transfer_anchor: self.is_transfer_anchor = self._io.read_u1() if self.has_field_vehicle_config_id: self.vehicle_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_vehicle_gadget_id: self.vehicle_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_mist_zone_id(self): if hasattr(self, '_m_has_field_mist_zone_id'): return self._m_has_field_mist_zone_id self._m_has_field_mist_zone_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_mist_zone_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_is_transfer_anchor(self): if hasattr(self, '_m_has_field_is_transfer_anchor'): return self._m_has_field_is_transfer_anchor self._m_has_field_is_transfer_anchor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_transfer_anchor', None) @property def has_field_vehicle_config_id(self): if hasattr(self, '_m_has_field_vehicle_config_id'): return self._m_has_field_vehicle_config_id self._m_has_field_vehicle_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_vehicle_config_id', None) @property def has_field_vehicle_gadget_id(self): if hasattr(self, '_m_has_field_vehicle_gadget_id'): return self._m_has_field_vehicle_gadget_id self._m_has_field_vehicle_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_vehicle_gadget_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class QuestGuideStyleComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigEntityAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigEntityAudio(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigAvatarAudio(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetAudio(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigVehicleAudio(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigMonsterAudio(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCharacterAudio(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class OfferingLevelUpExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_offering_id: self.offering_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_max_level: self.is_max_level = self._io.read_u1() if self.has_field_consume_item_config_vec: self.consume_item_config_vec = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_vec: self.action_vec = Output.ArrayOfOfferingActionContentLengthS(self._io, self, self._root) if self.has_field_cut_scene_id: self.cut_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_auto_take_reward: self.is_auto_take_reward = self._io.read_u1() @property def has_field_consume_item_config_vec(self): if hasattr(self, '_m_has_field_consume_item_config_vec'): return self._m_has_field_consume_item_config_vec self._m_has_field_consume_item_config_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_consume_item_config_vec', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_offering_id(self): if hasattr(self, '_m_has_field_offering_id'): return self._m_has_field_offering_id self._m_has_field_offering_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_offering_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_is_max_level(self): if hasattr(self, '_m_has_field_is_max_level'): return self._m_has_field_is_max_level self._m_has_field_is_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_max_level', None) @property def has_field_cut_scene_id(self): if hasattr(self, '_m_has_field_cut_scene_id'): return self._m_has_field_cut_scene_id self._m_has_field_cut_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cut_scene_id', None) @property def has_field_action_vec(self): if hasattr(self, '_m_has_field_action_vec'): return self._m_has_field_action_vec self._m_has_field_action_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_action_vec', None) @property def has_field_is_auto_take_reward(self): if hasattr(self, '_m_has_field_is_auto_take_reward'): return self._m_has_field_is_auto_take_reward self._m_has_field_is_auto_take_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_auto_take_reward', None) class ActivityArenaChallengeLevelInfoExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_preview_id: self.monster_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_config: self.monster_config = AuxTypes.String(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc_params: self.level_desc_params = AuxTypes.String(self._io, self, self._root) if self.has_field_monster_preview_id_hard_challenge: self.monster_preview_id_hard_challenge = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_config_hard_challenge: self.monster_config_hard_challenge = AuxTypes.String(self._io, self, self._root) if self.has_field_level_hard_challenge_desc: self.level_hard_challenge_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_hard_challenge_desc_params: self.level_hard_challenge_desc_params = AuxTypes.String(self._io, self, self._root) if self.has_field_level_detail_desc: self.level_detail_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id_list: self.challenge_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_challenge_id_list(self): if hasattr(self, '_m_has_field_challenge_id_list'): return self._m_has_field_challenge_id_list self._m_has_field_challenge_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_challenge_id_list', None) @property def has_field_monster_config_hard_challenge(self): if hasattr(self, '_m_has_field_monster_config_hard_challenge'): return self._m_has_field_monster_config_hard_challenge self._m_has_field_monster_config_hard_challenge = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_monster_config_hard_challenge', None) @property def has_field_level_detail_desc(self): if hasattr(self, '_m_has_field_level_detail_desc'): return self._m_has_field_level_detail_desc self._m_has_field_level_detail_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_level_detail_desc', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_level_hard_challenge_desc(self): if hasattr(self, '_m_has_field_level_hard_challenge_desc'): return self._m_has_field_level_hard_challenge_desc self._m_has_field_level_hard_challenge_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_level_hard_challenge_desc', None) @property def has_field_monster_preview_id_hard_challenge(self): if hasattr(self, '_m_has_field_monster_preview_id_hard_challenge'): return self._m_has_field_monster_preview_id_hard_challenge self._m_has_field_monster_preview_id_hard_challenge = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_monster_preview_id_hard_challenge', None) @property def has_field_level_hard_challenge_desc_params(self): if hasattr(self, '_m_has_field_level_hard_challenge_desc_params'): return self._m_has_field_level_hard_challenge_desc_params self._m_has_field_level_hard_challenge_desc_params = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_level_hard_challenge_desc_params', None) @property def has_field_level_desc_params(self): if hasattr(self, '_m_has_field_level_desc_params'): return self._m_has_field_level_desc_params self._m_has_field_level_desc_params = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_level_desc_params', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_level_desc', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_monster_config(self): if hasattr(self, '_m_has_field_monster_config'): return self._m_has_field_monster_config self._m_has_field_monster_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_monster_config', None) @property def has_field_monster_preview_id(self): if hasattr(self, '_m_has_field_monster_preview_id'): return self._m_has_field_monster_preview_id self._m_has_field_monster_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_preview_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class KvpOfDictEnumInputActionGroupTypeArrayOfEnumInputActionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumInputActionGroupType(self._io, self, self._root) self.value = Output.ArrayOfEnumInputActionTypeLengthU(self._io, self, self._root) class AsterTeamBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class EnumRandTaskContentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RandTaskContentType, self.data.value) return getattr(self, '_m_value', None) class RefreshPolicyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRefreshType(self._io, self, self._root) if self.has_field_time: self.time = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_time', None) class ArrayOfWinterCampDropGroupLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.WinterCampDropGroup(self._io, self, self._root)) class EnumSubChallengeBannerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SubChallengeBannerType, self.data.value) return getattr(self, '_m_value', None) class StrengthenDungeonTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrLayerGroupRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAbilityStateOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeworldLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumVolatileTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumVolatileType(self._io, self, self._root)) class ActivitySumoSwitchSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param: self.desc_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_pre = self._io.read_s1() @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc_param(self): if hasattr(self, '_m_has_field_desc_param'): return self._m_has_field_desc_param self._m_has_field_desc_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc_param', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_icon_name_hash(self): if hasattr(self, '_m_has_field_icon_name_hash'): return self._m_has_field_icon_name_hash self._m_has_field_icon_name_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon_name_hash', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class DragonSpineEnhanceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireMonsterBeingHitAfterImage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_index: self.effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_index', None) class AiPerceptionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_feature_tag_i_ds: self.feature_tag_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_perception_template_id: self.perception_template_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_feature_tag_i_ds(self): if hasattr(self, '_m_has_field_feature_tag_i_ds'): return self._m_has_field_feature_tag_i_ds self._m_has_field_feature_tag_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_feature_tag_i_ds', None) @property def has_field_perception_template_id(self): if hasattr(self, '_m_has_field_perception_template_id'): return self._m_has_field_perception_template_id self._m_has_field_perception_template_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_perception_template_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigCustomAttackBox(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_custom_attack_box_size_x: self.custom_attack_box_size_x = self._io.read_f4le() if self.has_field_custom_attack_box_size_y: self.custom_attack_box_size_y = self._io.read_f4le() if self.has_field_custom_attack_box_size_z: self.custom_attack_box_size_z = self._io.read_f4le() @property def has_field_custom_attack_box_size_x(self): if hasattr(self, '_m_has_field_custom_attack_box_size_x'): return self._m_has_field_custom_attack_box_size_x self._m_has_field_custom_attack_box_size_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_attack_box_size_x', None) @property def has_field_custom_attack_box_size_y(self): if hasattr(self, '_m_has_field_custom_attack_box_size_y'): return self._m_has_field_custom_attack_box_size_y self._m_has_field_custom_attack_box_size_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_custom_attack_box_size_y', None) @property def has_field_custom_attack_box_size_z(self): if hasattr(self, '_m_has_field_custom_attack_box_size_z'): return self._m_has_field_custom_attack_box_size_z self._m_has_field_custom_attack_box_size_z = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_custom_attack_box_size_z', None) class EnumAnimalCodexCountType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AnimalCodexCountType, self.data.value) return getattr(self, '_m_value', None) class HuntingClueGatherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_id: self.gather_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_group_id: self.gather_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_clue_gather: self.is_clue_gather = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_gather_id(self): if hasattr(self, '_m_has_field_gather_id'): return self._m_has_field_gather_id self._m_has_field_gather_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gather_id', None) @property def has_field_gather_group_id(self): if hasattr(self, '_m_has_field_gather_group_id'): return self._m_has_field_gather_group_id self._m_has_field_gather_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gather_group_id', None) @property def has_field_is_clue_gather(self): if hasattr(self, '_m_has_field_is_clue_gather'): return self._m_has_field_is_clue_gather self._m_has_field_is_clue_gather = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_clue_gather', None) class HomeworldEnterEditorMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_editor_modifier_names: self.editor_modifier_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_world_modifier_names: self.world_modifier_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_editor_modifier_names(self): if hasattr(self, '_m_has_field_editor_modifier_names'): return self._m_has_field_editor_modifier_names self._m_has_field_editor_modifier_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_editor_modifier_names', None) @property def has_field_world_modifier_names(self): if hasattr(self, '_m_has_field_world_modifier_names'): return self._m_has_field_world_modifier_names self._m_has_field_world_modifier_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_world_modifier_names', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictAuxTypesStringU1(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = self._io.read_u1() class EnumConfigAiCombatSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigAiCombatSkillType, self.data.value) return getattr(self, '_m_value', None) class BlossomChestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoolDownInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cool_down_time: self.cool_down_time = self._io.read_f4le() if self.has_field_token: self.token = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cool_down_time(self): if hasattr(self, '_m_has_field_cool_down_time'): return self._m_has_field_cool_down_time self._m_has_field_cool_down_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cool_down_time', None) @property def has_field_token(self): if hasattr(self, '_m_has_field_token'): return self._m_has_field_token self._m_has_field_token = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_token', None) class EnumTalkBeginWay(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkBeginWay, self.data.value) return getattr(self, '_m_value', None) class AudioEmitterMultiPositionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2fireworksChallengeDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionOnGlobalValueChangeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_is_delay: self.is_delay = self._io.read_u1() if self.has_field_delay_time: self.delay_time = self._io.read_f4le() @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_is_delay(self): if hasattr(self, '_m_has_field_is_delay'): return self._m_has_field_is_delay self._m_has_field_is_delay = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_delay', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_delay_time(self): if hasattr(self, '_m_has_field_delay_time'): return self._m_has_field_delay_time self._m_has_field_delay_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_delay_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class BattleFervorStateIdTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTalkHeroType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkHeroType, self.data.value) return getattr(self, '_m_value', None) class ChatExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_channel: self.channel = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = self._io.read_f4le() if self.has_field_tab_shown_name: self.tab_shown_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chat_channel_icon: self.chat_channel_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_tag_other: self.tag_other = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_self: self.tag_self = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enter: self.enter = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_leave: self.leave = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_channel(self): if hasattr(self, '_m_has_field_channel'): return self._m_has_field_channel self._m_has_field_channel = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_channel', None) @property def has_field_enter(self): if hasattr(self, '_m_has_field_enter'): return self._m_has_field_enter self._m_has_field_enter = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_enter', None) @property def has_field_tag_self(self): if hasattr(self, '_m_has_field_tag_self'): return self._m_has_field_tag_self self._m_has_field_tag_self = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_tag_self', None) @property def has_field_chat_channel_icon(self): if hasattr(self, '_m_has_field_chat_channel_icon'): return self._m_has_field_chat_channel_icon self._m_has_field_chat_channel_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_chat_channel_icon', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_tab_shown_name(self): if hasattr(self, '_m_has_field_tab_shown_name'): return self._m_has_field_tab_shown_name self._m_has_field_tab_shown_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tab_shown_name', None) @property def has_field_tag_other(self): if hasattr(self, '_m_has_field_tag_other'): return self._m_has_field_tag_other self._m_has_field_tag_other = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tag_other', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_leave(self): if hasattr(self, '_m_has_field_leave'): return self._m_has_field_leave self._m_has_field_leave = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_leave', None) class VehicleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldLimitShopExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementAdjustMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_change_interval: self.change_interval = self._io.read_f4le() if self.has_field_element_modifies: self.element_modifies = Output.DictOfEnumElementTypeAuxTypesString(self._io, self, self._root) @property def has_field_change_interval(self): if hasattr(self, '_m_has_field_change_interval'): return self._m_has_field_change_interval self._m_has_field_change_interval = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_change_interval', None) @property def has_field_element_modifies(self): if hasattr(self, '_m_has_field_element_modifies'): return self._m_has_field_element_modifies self._m_has_field_element_modifies = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_modifies', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ReunionPrivilegeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigAbilityModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAbilityModifier(self._io, self, self._root)) class EnumDungeonSubType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonSubType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfBowDrawTimeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BowDrawTime(self._io, self, self._root)) class ConfigAiSpacialWanderSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSpacialWanderData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSpacialWanderData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ReputationLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireworksExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reform_param_list: self.reform_param_list = Output.ArrayOfFireworksReformParamConfigLengthS(self._io, self, self._root) if self.has_field_fireworks_type: self.fireworks_type = Output.EnumFireworksType(self._io, self, self._root) if self.has_field_lift_off_effect_name: self.lift_off_effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_explode_effect_name: self.explode_effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_detailed_desc: self.detailed_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_explode_effect_name(self): if hasattr(self, '_m_has_field_explode_effect_name'): return self._m_has_field_explode_effect_name self._m_has_field_explode_effect_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_explode_effect_name', None) @property def has_field_lift_off_effect_name(self): if hasattr(self, '_m_has_field_lift_off_effect_name'): return self._m_has_field_lift_off_effect_name self._m_has_field_lift_off_effect_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_lift_off_effect_name', None) @property def has_field_fireworks_type(self): if hasattr(self, '_m_has_field_fireworks_type'): return self._m_has_field_fireworks_type self._m_has_field_fireworks_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_fireworks_type', None) @property def has_field_reform_param_list(self): if hasattr(self, '_m_has_field_reform_param_list'): return self._m_has_field_reform_param_list self._m_has_field_reform_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reform_param_list', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_detailed_desc(self): if hasattr(self, '_m_has_field_detailed_desc'): return self._m_has_field_detailed_desc self._m_has_field_detailed_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_detailed_desc', None) class StageReadyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_stage_ready: self.on_stage_ready = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_stage_ready(self): if hasattr(self, '_m_has_field_on_stage_ready'): return self._m_has_field_on_stage_ready self._m_has_field_on_stage_ready = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_stage_ready', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class UiInteractTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RelationalOperationPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class Predicated(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.BaseUtilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_predicates: self.target_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_success_actions: self.success_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_fail_actions: self.fail_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_fail_actions(self): if hasattr(self, '_m_has_field_fail_actions'): return self._m_has_field_fail_actions self._m_has_field_fail_actions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fail_actions', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_success_actions(self): if hasattr(self, '_m_has_field_success_actions'): return self._m_has_field_success_actions self._m_has_field_success_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_success_actions', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_target_predicates(self): if hasattr(self, '_m_has_field_target_predicates'): return self._m_has_field_target_predicates self._m_has_field_target_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_predicates', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ExhibitionDisplayCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEFootprintPlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EFootprintPlatform, self.data.value) return getattr(self, '_m_value', None) class ConfigMetaConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BartenderFormulaExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeAntiErosionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigJob(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigJob(self._io, self, self._root)) class DictOfAuxTypesStringDispConfigBaseStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigBaseStateIdInfo(self._io, self, self._root)) class ConfigCameraSplineBasePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_euler_angle: self.euler_angle = Output.Vector(self._io, self, self._root) if self.has_field_dutch: self.dutch = self._io.read_f4le() if self.has_field_length_ratio: self.length_ratio = self._io.read_f4le() if self.has_field_s_list: self.s_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_t_list: self.t_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_euler_angle(self): if hasattr(self, '_m_has_field_euler_angle'): return self._m_has_field_euler_angle self._m_has_field_euler_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_euler_angle', None) @property def has_field_t_list(self): if hasattr(self, '_m_has_field_t_list'): return self._m_has_field_t_list self._m_has_field_t_list = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_t_list', None) @property def has_field_length_ratio(self): if hasattr(self, '_m_has_field_length_ratio'): return self._m_has_field_length_ratio self._m_has_field_length_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_length_ratio', None) @property def has_field_s_list(self): if hasattr(self, '_m_has_field_s_list'): return self._m_has_field_s_list self._m_has_field_s_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_s_list', None) @property def has_field_dutch(self): if hasattr(self, '_m_has_field_dutch'): return self._m_has_field_dutch self._m_has_field_dutch = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dutch', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) class ConfigAvatarFocusGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ps4: self.ps4 = Output.ConfigAvatarFocus(self._io, self, self._root) if self.has_field_ps5: self.ps5 = Output.ConfigAvatarFocus(self._io, self, self._root) if self.has_field_pc: self.pc = Output.ConfigAvatarFocus(self._io, self, self._root) if self.has_field_other: self.other = Output.ConfigAvatarFocus(self._io, self, self._root) @property def has_field_ps4(self): if hasattr(self, '_m_has_field_ps4'): return self._m_has_field_ps4 self._m_has_field_ps4 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ps4', None) @property def has_field_ps5(self): if hasattr(self, '_m_has_field_ps5'): return self._m_has_field_ps5 self._m_has_field_ps5 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ps5', None) @property def has_field_pc(self): if hasattr(self, '_m_has_field_pc'): return self._m_has_field_pc self._m_has_field_pc = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_pc', None) @property def has_field_other(self): if hasattr(self, '_m_has_field_other'): return self._m_has_field_other self._m_has_field_other = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_other', None) class EnumMpPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MpPlayType, self.data.value) return getattr(self, '_m_value', None) class MaterialFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ByCompareWithTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_use_owner: self.use_owner = self._io.read_u1() if self.has_field_property: self.property = Output.EnumCompareProperty(self._io, self, self._root) @property def has_field_use_owner(self): if hasattr(self, '_m_has_field_use_owner'): return self._m_has_field_use_owner self._m_has_field_use_owner = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_owner', None) @property def has_field_property(self): if hasattr(self, '_m_has_field_property'): return self._m_has_field_property self._m_has_field_property = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_property', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MusicGameParamEqualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSTextMapLevelStruct(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.TextMapLevelStruct(self._io, self, self._root) class GadgetCurveExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFatherChallengeProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FatherChallengeProperty, self.data.value) return getattr(self, '_m_value', None) class MechanicusMapPointExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coord_x: self.coord_x = self._io.read_f4le() if self.has_field_coord_y: self.coord_y = self._io.read_f4le() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_coord_x(self): if hasattr(self, '_m_has_field_coord_x'): return self._m_has_field_coord_x self._m_has_field_coord_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_coord_x', None) @property def has_field_coord_y(self): if hasattr(self, '_m_has_field_coord_y'): return self._m_has_field_coord_y self._m_has_field_coord_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_coord_y', None) class ShopMaterialOrderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigUiIndicator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_icon: self.icon = Output.TemplateParamString(self._io, self, self._root) if self.has_field_distance_show: self.distance_show = Output.EnumIndicatorDistanceInfoType(self._io, self, self._root) if self.has_field_follow_move: self.follow_move = self._io.read_u1() if self.has_field_indicator: self.indicator = Output.ArrayOfIndicatorLogicLengthU(self._io, self, self._root) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_icon', None) @property def has_field_distance_show(self): if hasattr(self, '_m_has_field_distance_show'): return self._m_has_field_distance_show self._m_has_field_distance_show = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_distance_show', None) @property def has_field_follow_move(self): if hasattr(self, '_m_has_field_follow_move'): return self._m_has_field_follow_move self._m_has_field_follow_move = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_follow_move', None) @property def has_field_indicator(self): if hasattr(self, '_m_has_field_indicator'): return self._m_has_field_indicator self._m_has_field_indicator = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_indicator', None) class EnumSourceJumpType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SourceJumpType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeUEnumPositionModifyState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.EnumPositionModifyState(self._io, self, self._root) class DoWatcherSystemAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_authority_only: self.authority_only = self._io.read_u1() if self.has_field_in_threat_list_only: self.in_threat_list_only = self._io.read_u1() @property def has_field_authority_only(self): if hasattr(self, '_m_has_field_authority_only'): return self._m_has_field_authority_only self._m_has_field_authority_only = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_authority_only', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_in_threat_list_only(self): if hasattr(self, '_m_has_field_in_threat_list_only'): return self._m_has_field_in_threat_list_only self._m_has_field_in_threat_list_only = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_in_threat_list_only', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_watcher_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class MaterialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelBlockMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_block_id: self.block_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_ignore_block_position: self.is_ignore_block_position = self._io.read_u1() if self.has_field_block_center_x: self.block_center_x = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_block_center_z: self.block_center_z = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_block_id(self): if hasattr(self, '_m_has_field_block_id'): return self._m_has_field_block_id self._m_has_field_block_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_block_id', None) @property def has_field_is_ignore_block_position(self): if hasattr(self, '_m_has_field_is_ignore_block_position'): return self._m_has_field_is_ignore_block_position self._m_has_field_is_ignore_block_position = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_ignore_block_position', None) @property def has_field_block_center_x(self): if hasattr(self, '_m_has_field_block_center_x'): return self._m_has_field_block_center_x self._m_has_field_block_center_x = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_block_center_x', None) @property def has_field_block_center_z(self): if hasattr(self, '_m_has_field_block_center_z'): return self._m_has_field_block_center_z self._m_has_field_block_center_z = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_block_center_z', None) class ConfigPerfNumberItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class BlessingScanTypeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChargeBarStyleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfRandTaskDropConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandTaskDropConfig(self._io, self, self._root)) class ByUnlockTalentParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_talent_param: self.talent_param = AuxTypes.String(self._io, self, self._root) @property def has_field_talent_param(self): if hasattr(self, '_m_has_field_talent_param'): return self._m_has_field_talent_param self._m_has_field_talent_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talent_param', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class GalleryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGalleryType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_enable_single_prepare: self.is_enable_single_prepare = self._io.read_u1() if self.has_field_single_prepare_time: self.single_prepare_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_enable_mp_prepare: self.is_enable_mp_prepare = self._io.read_u1() if self.has_field_mp_prepare_time: self.mp_prepare_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_permit_input_in_prepare: self.is_permit_input_in_prepare = self._io.read_u1() if self.has_field_can_interrupt_by_client: self.can_interrupt_by_client = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_control_group_id: self.control_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_furniture_id: self.group_furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revive_point_group_id: self.revive_point_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revive_point_config_id: self.revive_point_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group: self.ability_group = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_group_list: self.ability_group_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_limit_region: self.limit_region = AuxTypes.String(self._io, self, self._root) if self.has_field_center_scene_id: self.center_scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_pos_list: self.center_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_center_radius: self.center_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_duration: self.duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_name: self.gallery_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_msg: self.gallery_msg = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pic: self.pic = AuxTypes.String(self._io, self, self._root) if self.has_field_target: self.target = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_audio_values: self.start_audio_values = AuxTypes.String(self._io, self, self._root) if self.has_field_end_audio_values: self.end_audio_values = AuxTypes.String(self._io, self, self._root) if self.has_field_selectable_ability_groups: self.selectable_ability_groups = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_team_ability_group_list: self.team_ability_group_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_selectable_team_ability_group_list: self.selectable_team_ability_group_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_disable_group_default_revise_level: self.is_disable_group_default_revise_level = self._io.read_u1() @property def has_field_center_radius(self): if hasattr(self, '_m_has_field_center_radius'): return self._m_has_field_center_radius self._m_has_field_center_radius = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_center_radius', None) @property def has_field_center_scene_id(self): if hasattr(self, '_m_has_field_center_scene_id'): return self._m_has_field_center_scene_id self._m_has_field_center_scene_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_center_scene_id', None) @property def has_field_ability_group(self): if hasattr(self, '_m_has_field_ability_group'): return self._m_has_field_ability_group self._m_has_field_ability_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_ability_group', None) @property def has_field_is_enable_mp_prepare(self): if hasattr(self, '_m_has_field_is_enable_mp_prepare'): return self._m_has_field_is_enable_mp_prepare self._m_has_field_is_enable_mp_prepare = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_enable_mp_prepare', None) @property def has_field_is_enable_single_prepare(self): if hasattr(self, '_m_has_field_is_enable_single_prepare'): return self._m_has_field_is_enable_single_prepare self._m_has_field_is_enable_single_prepare = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_enable_single_prepare', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_group_furniture_id(self): if hasattr(self, '_m_has_field_group_furniture_id'): return self._m_has_field_group_furniture_id self._m_has_field_group_furniture_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_group_furniture_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_control_group_id(self): if hasattr(self, '_m_has_field_control_group_id'): return self._m_has_field_control_group_id self._m_has_field_control_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_control_group_id', None) @property def has_field_revive_point_group_id(self): if hasattr(self, '_m_has_field_revive_point_group_id'): return self._m_has_field_revive_point_group_id self._m_has_field_revive_point_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_revive_point_group_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_is_disable_group_default_revise_level(self): if hasattr(self, '_m_has_field_is_disable_group_default_revise_level'): return self._m_has_field_is_disable_group_default_revise_level self._m_has_field_is_disable_group_default_revise_level = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_is_disable_group_default_revise_level', None) @property def has_field_gallery_name(self): if hasattr(self, '_m_has_field_gallery_name'): return self._m_has_field_gallery_name self._m_has_field_gallery_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_gallery_name', None) @property def has_field_is_permit_input_in_prepare(self): if hasattr(self, '_m_has_field_is_permit_input_in_prepare'): return self._m_has_field_is_permit_input_in_prepare self._m_has_field_is_permit_input_in_prepare = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_permit_input_in_prepare', None) @property def has_field_mp_prepare_time(self): if hasattr(self, '_m_has_field_mp_prepare_time'): return self._m_has_field_mp_prepare_time self._m_has_field_mp_prepare_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_mp_prepare_time', None) @property def has_field_start_audio_values(self): if hasattr(self, '_m_has_field_start_audio_values'): return self._m_has_field_start_audio_values self._m_has_field_start_audio_values = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_start_audio_values', None) @property def has_field_limit_region(self): if hasattr(self, '_m_has_field_limit_region'): return self._m_has_field_limit_region self._m_has_field_limit_region = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_limit_region', None) @property def has_field_revive_point_config_id(self): if hasattr(self, '_m_has_field_revive_point_config_id'): return self._m_has_field_revive_point_config_id self._m_has_field_revive_point_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_revive_point_config_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_selectable_ability_groups(self): if hasattr(self, '_m_has_field_selectable_ability_groups'): return self._m_has_field_selectable_ability_groups self._m_has_field_selectable_ability_groups = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_selectable_ability_groups', None) @property def has_field_selectable_team_ability_group_list(self): if hasattr(self, '_m_has_field_selectable_team_ability_group_list'): return self._m_has_field_selectable_team_ability_group_list self._m_has_field_selectable_team_ability_group_list = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_selectable_team_ability_group_list', None) @property def has_field_end_audio_values(self): if hasattr(self, '_m_has_field_end_audio_values'): return self._m_has_field_end_audio_values self._m_has_field_end_audio_values = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_end_audio_values', None) @property def has_field_center_pos_list(self): if hasattr(self, '_m_has_field_center_pos_list'): return self._m_has_field_center_pos_list self._m_has_field_center_pos_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_center_pos_list', None) @property def has_field_single_prepare_time(self): if hasattr(self, '_m_has_field_single_prepare_time'): return self._m_has_field_single_prepare_time self._m_has_field_single_prepare_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_single_prepare_time', None) @property def has_field_gallery_msg(self): if hasattr(self, '_m_has_field_gallery_msg'): return self._m_has_field_gallery_msg self._m_has_field_gallery_msg = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_gallery_msg', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_duration', None) @property def has_field_pic(self): if hasattr(self, '_m_has_field_pic'): return self._m_has_field_pic self._m_has_field_pic = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_pic', None) @property def has_field_ability_group_list(self): if hasattr(self, '_m_has_field_ability_group_list'): return self._m_has_field_ability_group_list self._m_has_field_ability_group_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_ability_group_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_target', None) @property def has_field_can_interrupt_by_client(self): if hasattr(self, '_m_has_field_can_interrupt_by_client'): return self._m_has_field_can_interrupt_by_client self._m_has_field_can_interrupt_by_client = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_can_interrupt_by_client', None) @property def has_field_team_ability_group_list(self): if hasattr(self, '_m_has_field_team_ability_group_list'): return self._m_has_field_team_ability_group_list self._m_has_field_team_ability_group_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_team_ability_group_list', None) class ByHitElement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element: self.element = Output.EnumElementType(self._io, self, self._root) @property def has_field_element(self): if hasattr(self, '_m_has_field_element'): return self._m_has_field_element self._m_has_field_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class CustomLevelDungeonConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestContentType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_param_str: self.param_str = AuxTypes.String(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_param_str(self): if hasattr(self, '_m_has_field_param_str'): return self._m_has_field_param_str self._m_has_field_param_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param_str', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_count', None) class ConfigBornByStormLightning(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_height_ratio: self.hit_height_ratio = self._io.read_f4le() if self.has_field_select_range: self.select_range = self._io.read_f4le() if self.has_field_max_offset_len: self.max_offset_len = self._io.read_f4le() if self.has_field_lightning_hit_or_not_ratio: self.lightning_hit_or_not_ratio = self._io.read_f4le() @property def has_field_lightning_hit_or_not_ratio(self): if hasattr(self, '_m_has_field_lightning_hit_or_not_ratio'): return self._m_has_field_lightning_hit_or_not_ratio self._m_has_field_lightning_hit_or_not_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_lightning_hit_or_not_ratio', None) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def has_field_select_range(self): if hasattr(self, '_m_has_field_select_range'): return self._m_has_field_select_range self._m_has_field_select_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_select_range', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def has_field_max_offset_len(self): if hasattr(self, '_m_has_field_max_offset_len'): return self._m_has_field_max_offset_len self._m_has_field_max_offset_len = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_offset_len', None) @property def has_field_hit_height_ratio(self): if hasattr(self, '_m_has_field_hit_height_ratio'): return self._m_has_field_hit_height_ratio self._m_has_field_hit_height_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_height_ratio', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigMonsterHeadControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigHeadControl(self._io, self, self._root) @property def max_pitch_degree(self): if hasattr(self, '_m_max_pitch_degree'): return self._m_max_pitch_degree self._m_max_pitch_degree = self.base.max_pitch_degree return getattr(self, '_m_max_pitch_degree', None) @property def anim_states(self): if hasattr(self, '_m_anim_states'): return self._m_anim_states self._m_anim_states = self.base.anim_states return getattr(self, '_m_anim_states', None) @property def dont_anim_states(self): if hasattr(self, '_m_dont_anim_states'): return self._m_dont_anim_states self._m_dont_anim_states = self.base.dont_anim_states return getattr(self, '_m_dont_anim_states', None) @property def weight_speed(self): if hasattr(self, '_m_weight_speed'): return self._m_weight_speed self._m_weight_speed = self.base.weight_speed return getattr(self, '_m_weight_speed', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def use_white_anim_states(self): if hasattr(self, '_m_use_white_anim_states'): return self._m_use_white_anim_states self._m_use_white_anim_states = self.base.use_white_anim_states return getattr(self, '_m_use_white_anim_states', None) @property def use_head_control(self): if hasattr(self, '_m_use_head_control'): return self._m_use_head_control self._m_use_head_control = self.base.use_head_control return getattr(self, '_m_use_head_control', None) @property def max_yaw_degree(self): if hasattr(self, '_m_max_yaw_degree'): return self._m_max_yaw_degree self._m_max_yaw_degree = self.base.max_yaw_degree return getattr(self, '_m_max_yaw_degree', None) class ConfigAudioQuestOps(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_events_on_start: self.events_on_start = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_states_on_start: self.states_on_start = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) if self.has_field_events_on_finish: self.events_on_finish = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) if self.has_field_states_on_finish: self.states_on_finish = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) @property def has_field_events_on_finish(self): if hasattr(self, '_m_has_field_events_on_finish'): return self._m_has_field_events_on_finish self._m_has_field_events_on_finish = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_events_on_finish', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_states_on_start(self): if hasattr(self, '_m_has_field_states_on_start'): return self._m_has_field_states_on_start self._m_has_field_states_on_start = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_states_on_start', None) @property def has_field_states_on_finish(self): if hasattr(self, '_m_has_field_states_on_finish'): return self._m_has_field_states_on_finish self._m_has_field_states_on_finish = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_states_on_finish', None) @property def has_field_events_on_start(self): if hasattr(self, '_m_has_field_events_on_start'): return self._m_has_field_events_on_start self._m_has_field_events_on_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_events_on_start', None) class RogueDiaryQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdQuestRestriction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_accepted: self.quest_accepted = self._io.read_u1() if self.has_field_quest_states: self.quest_states = Output.ArrayOfEnumQuestStateLengthU(self._io, self, self._root) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_quest_accepted(self): if hasattr(self, '_m_has_field_quest_accepted'): return self._m_has_field_quest_accepted self._m_has_field_quest_accepted = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_accepted', None) @property def has_field_quest_states(self): if hasattr(self, '_m_has_field_quest_states'): return self._m_has_field_quest_states self._m_has_field_quest_states = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_quest_states', None) class ConfigWidgetClientCollector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_type: self.target_type = Output.EnumCollectorType(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_recharge_points: self.recharge_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_points: self.max_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_gadget_id: self.effect_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_use_gadget_id: self.use_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_allow_other_world: self.allow_other_world = self._io.read_u1() @property def has_field_max_points(self): if hasattr(self, '_m_has_field_max_points'): return self._m_has_field_max_points self._m_has_field_max_points = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_points', None) @property def has_field_allow_other_world(self): if hasattr(self, '_m_has_field_allow_other_world'): return self._m_has_field_allow_other_world self._m_has_field_allow_other_world = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_allow_other_world', None) @property def has_field_effect_gadget_id(self): if hasattr(self, '_m_has_field_effect_gadget_id'): return self._m_has_field_effect_gadget_id self._m_has_field_effect_gadget_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_effect_gadget_id', None) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def has_field_use_gadget_id(self): if hasattr(self, '_m_has_field_use_gadget_id'): return self._m_has_field_use_gadget_id self._m_has_field_use_gadget_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_use_gadget_id', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_recharge_points(self): if hasattr(self, '_m_has_field_recharge_points'): return self._m_has_field_recharge_points self._m_has_field_recharge_points = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_recharge_points', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_type', None) class EnumViewCacheType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ViewCacheType, self.data.value) return getattr(self, '_m_value', None) class DictOfEnumAbilityStateArrayOfEnumElementReactionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumAbilityStateArrayOfEnumElementReactionTypeLengthU(self._io, self, self._root)) class ArrayOfDirectionMaskLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DirectionMask(self._io, self, self._root)) class SendEffectTriggerToLineEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAnimatorParamType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_float_value: self.float_value = self._io.read_f4le() @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_parameter', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_float_value(self): if hasattr(self, '_m_has_field_float_value'): return self._m_has_field_float_value self._m_has_field_float_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_float_value', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_effect_pattern', None) class EnumRoutineActionype(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoutineActionype, self.data.value) return getattr(self, '_m_value', None) class DispConfigControlPart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigControlPart(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigControlPartByIk(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigControlPartByIkccd(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigHomeworldSceneAutoGen(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_list: self.block_list = Output.ArrayOfConfigHomeworldBlockAutoGenLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_block_list(self): if hasattr(self, '_m_has_field_block_list'): return self._m_has_field_block_list self._m_has_field_block_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_block_list', None) class AttachModifierToClimateMeterMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class MpPlayMatchExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUVoiceTriggerIdentity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.VoiceTriggerIdentity(self._io, self, self._root) class ItemConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_dropable', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_desc', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_use_level', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_item_type', None) class GadgetTitleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) class ShopPreconditionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTargetPosToSelfPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetPosToSelfPosType, self.data.value) return getattr(self, '_m_value', None) class AntialiasingMethodComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionByPoseIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pose_i_ds: self.pose_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_enter_predicates: self.enter_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_exit_predicates: self.exit_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_enter_actions: self.enter_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_exit_actions: self.exit_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_enter_actions(self): if hasattr(self, '_m_has_field_enter_actions'): return self._m_has_field_enter_actions self._m_has_field_enter_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enter_actions', None) @property def has_field_exit_predicates(self): if hasattr(self, '_m_has_field_exit_predicates'): return self._m_has_field_exit_predicates self._m_has_field_exit_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_exit_predicates', None) @property def has_field_exit_actions(self): if hasattr(self, '_m_has_field_exit_actions'): return self._m_has_field_exit_actions self._m_has_field_exit_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_exit_actions', None) @property def has_field_pose_i_ds(self): if hasattr(self, '_m_has_field_pose_i_ds'): return self._m_has_field_pose_i_ds self._m_has_field_pose_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pose_i_ds', None) @property def has_field_enter_predicates(self): if hasattr(self, '_m_has_field_enter_predicates'): return self._m_has_field_enter_predicates self._m_has_field_enter_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enter_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigGuideCheckPlatformCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_platform: self.platform = Output.EnumGuidePlatform(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_platform(self): if hasattr(self, '_m_has_field_platform'): return self._m_has_field_platform self._m_has_field_platform = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_platform', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ShopmallRecommendConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeErosionMapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCoopTemperamentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopTemperamentType, self.data.value) return getattr(self, '_m_value', None) class ConfigLevelNavmeshPolygons(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_polygons: self.polygons = Output.ArrayOfConfigLevelNavmeshPolygonLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_polygons(self): if hasattr(self, '_m_has_field_polygons'): return self._m_has_field_polygons self._m_has_field_polygons = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_polygons', None) class EnumQuestCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigBillboard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attach_point: self.attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_offset_type: self.offset_type = Output.EnumBillboardOffsetType(self._io, self, self._root) if self.has_field_radius_offset: self.radius_offset = self._io.read_f4le() if self.has_field_enable_self_adapt: self.enable_self_adapt = self._io.read_u1() if self.has_field_show_distance: self.show_distance = self._io.read_f4le() if self.has_field_mark_show_distance: self.mark_show_distance = self._io.read_f4le() if self.has_field_name_show_distance: self.name_show_distance = self._io.read_f4le() if self.has_field_force_hide_all_bars: self.force_hide_all_bars = self._io.read_u1() @property def has_field_force_hide_all_bars(self): if hasattr(self, '_m_has_field_force_hide_all_bars'): return self._m_has_field_force_hide_all_bars self._m_has_field_force_hide_all_bars = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_force_hide_all_bars', None) @property def has_field_show_distance(self): if hasattr(self, '_m_has_field_show_distance'): return self._m_has_field_show_distance self._m_has_field_show_distance = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_distance', None) @property def has_field_enable_self_adapt(self): if hasattr(self, '_m_has_field_enable_self_adapt'): return self._m_has_field_enable_self_adapt self._m_has_field_enable_self_adapt = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_enable_self_adapt', None) @property def has_field_attach_point(self): if hasattr(self, '_m_has_field_attach_point'): return self._m_has_field_attach_point self._m_has_field_attach_point = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_attach_point', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_offset_type(self): if hasattr(self, '_m_has_field_offset_type'): return self._m_has_field_offset_type self._m_has_field_offset_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_offset_type', None) @property def has_field_mark_show_distance(self): if hasattr(self, '_m_has_field_mark_show_distance'): return self._m_has_field_mark_show_distance self._m_has_field_mark_show_distance = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_mark_show_distance', None) @property def has_field_radius_offset(self): if hasattr(self, '_m_has_field_radius_offset'): return self._m_has_field_radius_offset self._m_has_field_radius_offset = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_radius_offset', None) @property def has_field_name_show_distance(self): if hasattr(self, '_m_has_field_name_show_distance'): return self._m_has_field_name_show_distance self._m_has_field_name_show_distance = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_name_show_distance', None) class CustomGadgetTabExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueCreateGadgetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideKillMonsterCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_spawn_new: self.spawn_new = self._io.read_u1() if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_pos: self.monster_pos = Output.Vector(self._io, self, self._root) if self.has_field_monster_yaw: self.monster_yaw = self._io.read_f4le() @property def has_field_spawn_new(self): if hasattr(self, '_m_has_field_spawn_new'): return self._m_has_field_spawn_new self._m_has_field_spawn_new = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_spawn_new', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_monster_level', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_monster_id', None) @property def has_field_monster_yaw(self): if hasattr(self, '_m_has_field_monster_yaw'): return self._m_has_field_monster_yaw self._m_has_field_monster_yaw = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_monster_yaw', None) @property def has_field_monster_pos(self): if hasattr(self, '_m_has_field_monster_pos'): return self._m_has_field_monster_pos self._m_has_field_monster_pos = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_monster_pos', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class EnumSalesmanSpecialRewardObtainMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SalesmanSpecialRewardObtainMethod, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigPerfGradeItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfGradeItem(self._io, self, self._root) class AudioPlatformMoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionBySelfModifierElementDurabilityRatioMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_unique_modifier_name: self.unique_modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_action_queues: self.action_queues = Output.ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(self._io, self, self._root) @property def has_field_unique_modifier_name(self): if hasattr(self, '_m_has_field_unique_modifier_name'): return self._m_has_field_unique_modifier_name self._m_has_field_unique_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_unique_modifier_name', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_action_queues(self): if hasattr(self, '_m_has_field_action_queues'): return self._m_has_field_action_queues self._m_has_field_action_queues = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_action_queues', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ByAvatarIsHost(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_host: self.is_host = self._io.read_u1() @property def has_field_is_host(self): if hasattr(self, '_m_has_field_is_host'): return self._m_has_field_is_host self._m_has_field_is_host = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_host', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class CustomGadgetRootExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_root_gadget_id: self.root_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_context_type: self.context_type = Output.EnumCustomGadgetRootType(self._io, self, self._root) if self.has_field_page_title: self.page_title = AuxTypes.String(self._io, self, self._root) if self.has_field_recommend_config: self.recommend_config = AuxTypes.String(self._io, self, self._root) if self.has_field_tab_list: self.tab_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_page_title(self): if hasattr(self, '_m_has_field_page_title'): return self._m_has_field_page_title self._m_has_field_page_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_page_title', None) @property def has_field_context_type(self): if hasattr(self, '_m_has_field_context_type'): return self._m_has_field_context_type self._m_has_field_context_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_context_type', None) @property def has_field_root_gadget_id(self): if hasattr(self, '_m_has_field_root_gadget_id'): return self._m_has_field_root_gadget_id self._m_has_field_root_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_root_gadget_id', None) @property def has_field_recommend_config(self): if hasattr(self, '_m_has_field_recommend_config'): return self._m_has_field_recommend_config self._m_has_field_recommend_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_recommend_config', None) @property def has_field_tab_list(self): if hasattr(self, '_m_has_field_tab_list'): return self._m_has_field_tab_list self._m_has_field_tab_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tab_list', None) class ConfigForceField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class ConfigHomeworldBlockDefaultSave(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_id: self.block_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_persistent_furniture_list: self.persistent_furniture_list = Output.ArrayOfConfigHomeworldFurnitureDefaultSaveLengthU(self._io, self, self._root) if self.has_field_deploy_furniure_list: self.deploy_furniure_list = Output.ArrayOfConfigHomeworldFurnitureDefaultSaveLengthU(self._io, self, self._root) if self.has_field_deploy_npc_list: self.deploy_npc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_furniture_suite_list: self.furniture_suite_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_deploy_animal_list: self.deploy_animal_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_unlocked: self.is_unlocked = self._io.read_u1() if self.has_field_comfort_value: self.comfort_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weekend_djinn_info_list: self.weekend_djinn_info_list = Output.ArrayOfConfigHomeworldDjinnInfoDefaultSaveLengthU(self._io, self, self._root) if self.has_field_dot_pattern_list: self.dot_pattern_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_furniture_suite_list(self): if hasattr(self, '_m_has_field_furniture_suite_list'): return self._m_has_field_furniture_suite_list self._m_has_field_furniture_suite_list = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_furniture_suite_list', None) @property def has_field_comfort_value(self): if hasattr(self, '_m_has_field_comfort_value'): return self._m_has_field_comfort_value self._m_has_field_comfort_value = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_comfort_value', None) @property def has_field_deploy_furniure_list(self): if hasattr(self, '_m_has_field_deploy_furniure_list'): return self._m_has_field_deploy_furniure_list self._m_has_field_deploy_furniure_list = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_deploy_furniure_list', None) @property def has_field_persistent_furniture_list(self): if hasattr(self, '_m_has_field_persistent_furniture_list'): return self._m_has_field_persistent_furniture_list self._m_has_field_persistent_furniture_list = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_persistent_furniture_list', None) @property def has_field_deploy_npc_list(self): if hasattr(self, '_m_has_field_deploy_npc_list'): return self._m_has_field_deploy_npc_list self._m_has_field_deploy_npc_list = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_deploy_npc_list', None) @property def has_field_block_id(self): if hasattr(self, '_m_has_field_block_id'): return self._m_has_field_block_id self._m_has_field_block_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_block_id', None) @property def has_field_is_unlocked(self): if hasattr(self, '_m_has_field_is_unlocked'): return self._m_has_field_is_unlocked self._m_has_field_is_unlocked = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_is_unlocked', None) @property def has_field_dot_pattern_list(self): if hasattr(self, '_m_has_field_dot_pattern_list'): return self._m_has_field_dot_pattern_list self._m_has_field_dot_pattern_list = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_dot_pattern_list', None) @property def has_field_deploy_animal_list(self): if hasattr(self, '_m_has_field_deploy_animal_list'): return self._m_has_field_deploy_animal_list self._m_has_field_deploy_animal_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_deploy_animal_list', None) @property def has_field_weekend_djinn_info_list(self): if hasattr(self, '_m_has_field_weekend_djinn_info_list'): return self._m_has_field_weekend_djinn_info_list self._m_has_field_weekend_djinn_info_list = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_weekend_djinn_info_list', None) class BoolNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ConfigMusicUInt32listNonePresenceCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listMultiMemberCondition(self._io, self, self._root) @property def values(self): if hasattr(self, '_m_values'): return self._m_values self._m_values = self.base.values return getattr(self, '_m_values', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ArrayOfSgvConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SgvConfig(self._io, self, self._root)) class TurnModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigSubEquipControllerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSubEquipController(self._io, self, self._root)) class ExpeditionDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityScoreLimitExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAttackDoubleTrail(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAttackTrail(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trail2name: self.trail2name = AuxTypes.String(self._io, self, self._root) if self.has_field_trail_start2name: self.trail_start2name = AuxTypes.String(self._io, self, self._root) @property def entity_attack_filter(self): if hasattr(self, '_m_entity_attack_filter'): return self._m_entity_attack_filter self._m_entity_attack_filter = self.base.entity_attack_filter return getattr(self, '_m_entity_attack_filter', None) @property def use_custom_shape(self): if hasattr(self, '_m_use_custom_shape'): return self._m_use_custom_shape self._m_use_custom_shape = self.base.use_custom_shape return getattr(self, '_m_use_custom_shape', None) @property def filter_by_frame(self): if hasattr(self, '_m_filter_by_frame'): return self._m_filter_by_frame self._m_filter_by_frame = self.base.filter_by_frame return getattr(self, '_m_filter_by_frame', None) @property def has_field_trail2name(self): if hasattr(self, '_m_has_field_trail2name'): return self._m_has_field_trail2name self._m_has_field_trail2name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trail2name', None) @property def check_hit_layer_type(self): if hasattr(self, '_m_check_hit_layer_type'): return self._m_check_hit_layer_type self._m_check_hit_layer_type = self.base.check_hit_layer_type return getattr(self, '_m_check_hit_layer_type', None) @property def trigger_cd(self): if hasattr(self, '_m_trigger_cd'): return self._m_trigger_cd self._m_trigger_cd = self.base.trigger_cd return getattr(self, '_m_trigger_cd', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def trigger_type(self): if hasattr(self, '_m_trigger_type'): return self._m_trigger_type self._m_trigger_type = self.base.trigger_type return getattr(self, '_m_trigger_type', None) @property def trail_start_name(self): if hasattr(self, '_m_trail_start_name'): return self._m_trail_start_name self._m_trail_start_name = self.base.trail_start_name return getattr(self, '_m_trail_start_name', None) @property def hit_scene(self): if hasattr(self, '_m_hit_scene'): return self._m_hit_scene self._m_hit_scene = self.base.hit_scene return getattr(self, '_m_hit_scene', None) @property def massive_attack_ratio(self): if hasattr(self, '_m_massive_attack_ratio'): return self._m_massive_attack_ratio self._m_massive_attack_ratio = self.base.massive_attack_ratio return getattr(self, '_m_massive_attack_ratio', None) @property def trail_name(self): if hasattr(self, '_m_trail_name'): return self._m_trail_name self._m_trail_name = self.base.trail_name return getattr(self, '_m_trail_name', None) @property def has_field_trail_start2name(self): if hasattr(self, '_m_has_field_trail_start2name'): return self._m_has_field_trail_start2name self._m_has_field_trail_start2name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trail_start2name', None) @property def ignore_massive(self): if hasattr(self, '_m_ignore_massive'): return self._m_ignore_massive self._m_ignore_massive = self.base.ignore_massive return getattr(self, '_m_ignore_massive', None) class InputEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumKeyboardTypeConfigKeyboardLayoutItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumKeyboardType(self._io, self, self._root) self.value = Output.ConfigKeyboardLayoutItem(self._io, self, self._root) class OverflowTransformTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBeHitBlendShake(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBeHitBlendShake(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBeHitBlendShakeByAinmator(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class AudioRequirement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_info: self.info = AuxTypes.String(self._io, self, self._root) if self.has_field_values: self.values = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_info(self): if hasattr(self, '_m_has_field_info'): return self._m_has_field_info self._m_has_field_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_info', None) @property def has_field_values(self): if hasattr(self, '_m_has_field_values'): return self._m_has_field_values self._m_has_field_values = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_values', None) class KillGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_info: self.gadget_info = Output.SelectTargetsByChildren(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_gadget_info(self): if hasattr(self, '_m_has_field_gadget_info'): return self._m_has_field_gadget_info self._m_has_field_gadget_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_info', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RoguelikeCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_server_global_values: self.server_global_values = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_init_server_global_values: self.init_server_global_values = Output.DictOfAuxTypesStringF4(self._io, self, self._root) @property def has_field_server_global_values(self): if hasattr(self, '_m_has_field_server_global_values'): return self._m_has_field_server_global_values self._m_has_field_server_global_values = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_server_global_values', None) @property def has_field_init_server_global_values(self): if hasattr(self, '_m_has_field_init_server_global_values'): return self._m_has_field_init_server_global_values self._m_has_field_init_server_global_values = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_init_server_global_values', None) class EnumSortModifierType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SortModifierType, self.data.value) return getattr(self, '_m_value', None) class ElementReactionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByBigTeamBodyTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumMapAreaState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MapAreaState, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigBattleFervorUpdatePredicateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBattleFervorUpdatePredicate(self._io, self, self._root)) class EnumSectrGameObjectPathHashHackType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrGameObjectPathHashHackType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfScoreRuleLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ScoreRule(self._io, self, self._root)) class RandomQuestElem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_name: self.name = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pool_id', None) class QuestContentEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumQuestContentType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_count', None) class OpenStateCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumOpenStateCondType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class ConfigJudgeGroupEntityInView(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group_entity_list: self.group_entity_list = Output.ArrayOfConfigJudgeGroupEntityLengthU(self._io, self, self._root) @property def has_field_group_entity_list(self): if hasattr(self, '_m_has_field_group_entity_list'): return self._m_has_field_group_entity_list self._m_has_field_group_entity_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_entity_list', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class DictOfAuxTypesStringConfigPerfGradeItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfGradeItemOptionArrayInfo(self._io, self, self._root)) class TreeTypeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tree_pattern: self.tree_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_tree_type: self.tree_type = Output.EnumTreeType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_tree_pattern(self): if hasattr(self, '_m_has_field_tree_pattern'): return self._m_has_field_tree_pattern self._m_has_field_tree_pattern = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tree_pattern', None) @property def has_field_tree_type(self): if hasattr(self, '_m_has_field_tree_type'): return self._m_has_field_tree_type self._m_has_field_tree_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tree_type', None) class ConfigMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_velocity_force: self.velocity_force = Output.ConfigMoveVelocityForce(self._io, self, self._root) if self.has_field_handle_combat_task_immediately: self.handle_combat_task_immediately = self._io.read_u1() @property def has_field_velocity_force(self): if hasattr(self, '_m_has_field_velocity_force'): return self._m_has_field_velocity_force self._m_has_field_velocity_force = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_velocity_force', None) @property def has_field_handle_combat_task_immediately(self): if hasattr(self, '_m_has_field_handle_combat_task_immediately'): return self._m_has_field_handle_combat_task_immediately self._m_has_field_handle_combat_task_immediately = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_handle_combat_task_immediately', None) class DungeonRewardPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_active: self.is_active = self._io.read_u1() if self.has_field_drop_point_list: self.drop_point_list = Output.ArrayOfVectorLengthU(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_active', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_drop_point_list(self): if hasattr(self, '_m_has_field_drop_point_list'): return self._m_has_field_drop_point_list self._m_has_field_drop_point_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_drop_point_list', None) class ArrayOfIrodoriCardNumericalLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IrodoriCardNumerical(self._io, self, self._root)) class ArrayOfAbilityOverrideParamConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AbilityOverrideParamConfig(self._io, self, self._root)) class AudioAmbiencePositionedEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_event_name: self.event_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_min_init_delay: self.min_init_delay = self._io.read_f4le() if self.has_field_max_init_delay: self.max_init_delay = self._io.read_f4le() if self.has_field_min_interval: self.min_interval = self._io.read_f4le() if self.has_field_max_interval: self.max_interval = self._io.read_f4le() @property def has_field_event_name(self): if hasattr(self, '_m_has_field_event_name'): return self._m_has_field_event_name self._m_has_field_event_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_event_name', None) @property def has_field_max_init_delay(self): if hasattr(self, '_m_has_field_max_init_delay'): return self._m_has_field_max_init_delay self._m_has_field_max_init_delay = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_init_delay', None) @property def has_field_min_interval(self): if hasattr(self, '_m_has_field_min_interval'): return self._m_has_field_min_interval self._m_has_field_min_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_interval', None) @property def has_field_min_init_delay(self): if hasattr(self, '_m_has_field_min_init_delay'): return self._m_has_field_min_init_delay self._m_has_field_min_init_delay = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_init_delay', None) @property def has_field_max_interval(self): if hasattr(self, '_m_has_field_max_interval'): return self._m_has_field_max_interval self._m_has_field_max_interval = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_interval', None) class ConfigMoveStickToGround(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_step_height: self.max_step_height = self._io.read_f4le() if self.has_field_max_slope_angle: self.max_slope_angle = self._io.read_f4le() if self.has_field_height_to_ground: self.height_to_ground = self._io.read_f4le() if self.has_field_flexible_range: self.flexible_range = self._io.read_f4le() if self.has_field_is_stick_to_water: self.is_stick_to_water = self._io.read_u1() if self.has_field_ignore_barrier: self.ignore_barrier = self._io.read_u1() if self.has_field_unstick_when_down_slide: self.unstick_when_down_slide = Output.EnumUnstickAction(self._io, self, self._root) if self.has_field_unstick_when_up_slide: self.unstick_when_up_slide = Output.EnumUnstickAction(self._io, self, self._root) @property def has_field_max_slope_angle(self): if hasattr(self, '_m_has_field_max_slope_angle'): return self._m_has_field_max_slope_angle self._m_has_field_max_slope_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_slope_angle', None) @property def has_field_flexible_range(self): if hasattr(self, '_m_has_field_flexible_range'): return self._m_has_field_flexible_range self._m_has_field_flexible_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_flexible_range', None) @property def has_field_ignore_barrier(self): if hasattr(self, '_m_has_field_ignore_barrier'): return self._m_has_field_ignore_barrier self._m_has_field_ignore_barrier = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_ignore_barrier', None) @property def has_field_is_stick_to_water(self): if hasattr(self, '_m_has_field_is_stick_to_water'): return self._m_has_field_is_stick_to_water self._m_has_field_is_stick_to_water = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_stick_to_water', None) @property def has_field_unstick_when_down_slide(self): if hasattr(self, '_m_has_field_unstick_when_down_slide'): return self._m_has_field_unstick_when_down_slide self._m_has_field_unstick_when_down_slide = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_unstick_when_down_slide', None) @property def has_field_unstick_when_up_slide(self): if hasattr(self, '_m_has_field_unstick_when_up_slide'): return self._m_has_field_unstick_when_up_slide self._m_has_field_unstick_when_up_slide = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_unstick_when_up_slide', None) @property def has_field_max_step_height(self): if hasattr(self, '_m_has_field_max_step_height'): return self._m_has_field_max_step_height self._m_has_field_max_step_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_step_height', None) @property def has_field_height_to_ground(self): if hasattr(self, '_m_has_field_height_to_ground'): return self._m_has_field_height_to_ground self._m_has_field_height_to_ground = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_height_to_ground', None) class ArrayOfEnumVelocityForceTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumVelocityForceType(self._io, self, self._root)) class ConfigEffectData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_element_view: self.element_view = Output.ConfigElementView(self._io, self, self._root) if self.has_field_be_hit: self.be_hit = Output.ConfigBeHitEffect(self._io, self, self._root) if self.has_field_recover_energy: self.recover_energy = Output.ArrayOfConfigRecoverEnergyEffectLengthU(self._io, self, self._root) if self.has_field_effect_pool: self.effect_pool = Output.ConfigEffectPool(self._io, self, self._root) if self.has_field_scene_prop_shake_anim: self.scene_prop_shake_anim = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_effect_lod: self.effect_lod = Output.ConfigEffectLod(self._io, self, self._root) if self.has_field_skip_unindexed_effect_creation: self.skip_unindexed_effect_creation = Output.DictOfAuxTypesStringConfigSkipUnindexedEffectCreation(self._io, self, self._root) if self.has_field_token_force_enqueue_map: self.token_force_enqueue_map = Output.DictOfAuxTypesStringEnumTokenForceEnqueueReason(self._io, self, self._root) if self.has_field_token_force_handle_this_frame_array: self.token_force_handle_this_frame_array = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_token_ignore_tick_lod: self.token_ignore_tick_lod = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_logic_effect: self.logic_effect = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_token_force_handle_this_frame_array(self): if hasattr(self, '_m_has_field_token_force_handle_this_frame_array'): return self._m_has_field_token_force_handle_this_frame_array self._m_has_field_token_force_handle_this_frame_array = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_token_force_handle_this_frame_array', None) @property def has_field_token_ignore_tick_lod(self): if hasattr(self, '_m_has_field_token_ignore_tick_lod'): return self._m_has_field_token_ignore_tick_lod self._m_has_field_token_ignore_tick_lod = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_token_ignore_tick_lod', None) @property def has_field_scene_prop_shake_anim(self): if hasattr(self, '_m_has_field_scene_prop_shake_anim'): return self._m_has_field_scene_prop_shake_anim self._m_has_field_scene_prop_shake_anim = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_scene_prop_shake_anim', None) @property def has_field_logic_effect(self): if hasattr(self, '_m_has_field_logic_effect'): return self._m_has_field_logic_effect self._m_has_field_logic_effect = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_logic_effect', None) @property def has_field_skip_unindexed_effect_creation(self): if hasattr(self, '_m_has_field_skip_unindexed_effect_creation'): return self._m_has_field_skip_unindexed_effect_creation self._m_has_field_skip_unindexed_effect_creation = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_skip_unindexed_effect_creation', None) @property def has_field_element_view(self): if hasattr(self, '_m_has_field_element_view'): return self._m_has_field_element_view self._m_has_field_element_view = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_element_view', None) @property def has_field_effect_lod(self): if hasattr(self, '_m_has_field_effect_lod'): return self._m_has_field_effect_lod self._m_has_field_effect_lod = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_effect_lod', None) @property def has_field_token_force_enqueue_map(self): if hasattr(self, '_m_has_field_token_force_enqueue_map'): return self._m_has_field_token_force_enqueue_map self._m_has_field_token_force_enqueue_map = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_token_force_enqueue_map', None) @property def has_field_recover_energy(self): if hasattr(self, '_m_has_field_recover_energy'): return self._m_has_field_recover_energy self._m_has_field_recover_energy = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_recover_energy', None) @property def has_field_be_hit(self): if hasattr(self, '_m_has_field_be_hit'): return self._m_has_field_be_hit self._m_has_field_be_hit = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_be_hit', None) @property def has_field_effect_pool(self): if hasattr(self, '_m_has_field_effect_pool'): return self._m_has_field_effect_pool self._m_has_field_effect_pool = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_effect_pool', None) class ByHasLevelTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_level_tag: self.level_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_level_tag_id: self.level_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level_tag(self): if hasattr(self, '_m_has_field_level_tag'): return self._m_has_field_level_tag self._m_has_field_level_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level_tag', None) @property def has_field_level_tag_id(self): if hasattr(self, '_m_has_field_level_tag_id'): return self._m_has_field_level_tag_id self._m_has_field_level_tag_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_level_tag_id', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class PlaceNameActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomQuestFilterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_filter_type: self.filter_type = Output.EnumRandomQuestFilterType(self._io, self, self._root) if self.has_field_filter_factor: self.filter_factor = AuxTypes.String(self._io, self, self._root) if self.has_field_filter_param_list: self.filter_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_filter_type(self): if hasattr(self, '_m_has_field_filter_type'): return self._m_has_field_filter_type self._m_has_field_filter_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_filter_type', None) @property def has_field_filter_factor(self): if hasattr(self, '_m_has_field_filter_factor'): return self._m_has_field_filter_factor self._m_has_field_filter_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_filter_factor', None) @property def has_field_filter_param_list(self): if hasattr(self, '_m_has_field_filter_param_list'): return self._m_has_field_filter_param_list self._m_has_field_filter_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_filter_param_list', None) class HomeWorldServerGadgetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_gadget_id: self.server_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_server_gadget_id(self): if hasattr(self, '_m_has_field_server_gadget_id'): return self._m_has_field_server_gadget_id self._m_has_field_server_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_server_gadget_id', None) class MarkVisibilityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ContextConditionQuestState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumQuestState(self._io, self, self._root) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quest_id', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state', None) class ConfigShapeRect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_center_type: self.center_type = Output.EnumCenterPosType(self._io, self, self._root) if self.has_field_width: self.width = self._io.read_f4le() if self.has_field_length: self.length = self._io.read_f4le() @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def has_field_width(self): if hasattr(self, '_m_has_field_width'): return self._m_has_field_width self._m_has_field_width = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_width', None) @property def has_field_length(self): if hasattr(self, '_m_has_field_length'): return self._m_has_field_length self._m_has_field_length = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_length', None) @property def has_field_center_type(self): if hasattr(self, '_m_has_field_center_type'): return self._m_has_field_center_type self._m_has_field_center_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_center_type', None) class EnumShopRecommendTagType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopRecommendTagType, self.data.value) return getattr(self, '_m_value', None) class MonsterAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_affix: self.affix = AuxTypes.String(self._io, self, self._root) if self.has_field_comment: self.comment = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_common: self.is_common = self._io.read_u1() if self.has_field_pre_add: self.pre_add = self._io.read_u1() if self.has_field_is_legal: self.is_legal = AuxTypes.String(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_radar_hint_id: self.radar_hint_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_general_skill_icon: self.general_skill_icon = AuxTypes.String(self._io, self, self._root) @property def has_field_radar_hint_id(self): if hasattr(self, '_m_has_field_radar_hint_id'): return self._m_has_field_radar_hint_id self._m_has_field_radar_hint_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_radar_hint_id', None) @property def has_field_comment(self): if hasattr(self, '_m_has_field_comment'): return self._m_has_field_comment self._m_has_field_comment = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_comment', None) @property def has_field_is_common(self): if hasattr(self, '_m_has_field_is_common'): return self._m_has_field_is_common self._m_has_field_is_common = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_common', None) @property def has_field_affix(self): if hasattr(self, '_m_has_field_affix'): return self._m_has_field_affix self._m_has_field_affix = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_affix', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_is_legal(self): if hasattr(self, '_m_has_field_is_legal'): return self._m_has_field_is_legal self._m_has_field_is_legal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_legal', None) @property def has_field_pre_add(self): if hasattr(self, '_m_has_field_pre_add'): return self._m_has_field_pre_add self._m_has_field_pre_add = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_add', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_general_skill_icon(self): if hasattr(self, '_m_has_field_general_skill_icon'): return self._m_has_field_general_skill_icon self._m_has_field_general_skill_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_general_skill_icon', None) class BoredEventExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_event_type: self.event_type = Output.EnumBoardEventType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_enable: self.is_enable = self._io.read_u1() if self.has_field_add_bored: self.add_bored = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_max_bored: self.max_bored = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_is_enable(self): if hasattr(self, '_m_has_field_is_enable'): return self._m_has_field_is_enable self._m_has_field_is_enable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_enable', None) @property def has_field_event_type(self): if hasattr(self, '_m_has_field_event_type'): return self._m_has_field_event_type self._m_has_field_event_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_event_type', None) @property def has_field_add_bored(self): if hasattr(self, '_m_has_field_add_bored'): return self._m_has_field_add_bored self._m_has_field_add_bored = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_add_bored', None) @property def has_field_max_bored(self): if hasattr(self, '_m_has_field_max_bored'): return self._m_has_field_max_bored self._m_has_field_max_bored = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_bored', None) class LunaRitePreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id: self.unlock_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_quest_id2: self.unlock_quest_id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_player_level: self.unlock_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_quest_id: self.activity_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_push_tips_id: self.challenge_push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_plot_push_tips_id: self.plot_push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_plot_push_tips_pre_quest_id: self.plot_push_tips_pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_atmosphere: self.max_atmosphere = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_plot_push_tips_id(self): if hasattr(self, '_m_has_field_plot_push_tips_id'): return self._m_has_field_plot_push_tips_id self._m_has_field_plot_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_plot_push_tips_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_unlock_quest_id(self): if hasattr(self, '_m_has_field_unlock_quest_id'): return self._m_has_field_unlock_quest_id self._m_has_field_unlock_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_quest_id', None) @property def has_field_unlock_player_level(self): if hasattr(self, '_m_has_field_unlock_player_level'): return self._m_has_field_unlock_player_level self._m_has_field_unlock_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_player_level', None) @property def has_field_activity_quest_id(self): if hasattr(self, '_m_has_field_activity_quest_id'): return self._m_has_field_activity_quest_id self._m_has_field_activity_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_activity_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_plot_push_tips_pre_quest_id(self): if hasattr(self, '_m_has_field_plot_push_tips_pre_quest_id'): return self._m_has_field_plot_push_tips_pre_quest_id self._m_has_field_plot_push_tips_pre_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_plot_push_tips_pre_quest_id', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_challenge_push_tips_id(self): if hasattr(self, '_m_has_field_challenge_push_tips_id'): return self._m_has_field_challenge_push_tips_id self._m_has_field_challenge_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_challenge_push_tips_id', None) @property def has_field_unlock_quest_id2(self): if hasattr(self, '_m_has_field_unlock_quest_id2'): return self._m_has_field_unlock_quest_id2 self._m_has_field_unlock_quest_id2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_quest_id2', None) @property def has_field_max_atmosphere(self): if hasattr(self, '_m_has_field_max_atmosphere'): return self._m_has_field_max_atmosphere self._m_has_field_max_atmosphere = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_max_atmosphere', None) class DictOfAuxTypesVlqBase128LeSConfigAiCrabMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiCrabMoveData(self._io, self, self._root)) class ConfigRecordActorBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) if self.has_field_scale: self.scale = Output.Vector(self._io, self, self._root) if self.has_field_serial_id: self.serial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rot', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_serial_id(self): if hasattr(self, '_m_has_field_serial_id'): return self._m_has_field_serial_id self._m_has_field_serial_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_serial_id', None) class ConfigAbilityNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config: self.config = AuxTypes.String(self._io, self, self._root) if self.has_field_order_id: self.order_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_related_order_id: self.related_order_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_color_tag: self.color_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_tags: self.tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_data: self.data = Output.ArrayOfConfigAbilityDataLengthU(self._io, self, self._root) if self.has_field_children: self.children = Output.ArrayOfConfigAbilityNodeLengthU(self._io, self, self._root) @property def has_field_order_id(self): if hasattr(self, '_m_has_field_order_id'): return self._m_has_field_order_id self._m_has_field_order_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_order_id', None) @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_tags', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_config(self): if hasattr(self, '_m_has_field_config'): return self._m_has_field_config self._m_has_field_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config', None) @property def has_field_data(self): if hasattr(self, '_m_has_field_data'): return self._m_has_field_data self._m_has_field_data = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_data', None) @property def has_field_related_order_id(self): if hasattr(self, '_m_has_field_related_order_id'): return self._m_has_field_related_order_id self._m_has_field_related_order_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_related_order_id', None) @property def has_field_color_tag(self): if hasattr(self, '_m_has_field_color_tag'): return self._m_has_field_color_tag self._m_has_field_color_tag = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_color_tag', None) @property def has_field_children(self): if hasattr(self, '_m_has_field_children'): return self._m_has_field_children self._m_has_field_children = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_children', None) class ExpeditionOpenCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriFlowerGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAbilityStateToActions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ability_state: self.ability_state = Output.EnumAbilityState(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_ability_state(self): if hasattr(self, '_m_has_field_ability_state'): return self._m_has_field_ability_state self._m_has_field_ability_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_state', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) class ConfigLuaHack(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ui_lua_script_path: self.ui_lua_script_path = AuxTypes.String(self._io, self, self._root) if self.has_field_enable_lua_patch: self.enable_lua_patch = self._io.read_u1() if self.has_field_enable_all_context_lua_patch: self.enable_all_context_lua_patch = self._io.read_u1() if self.has_field_ui_lua_patch_context_startup_list: self.ui_lua_patch_context_startup_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_setup_view_list: self.ui_lua_patch_context_setup_view_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_post_setup_view_list: self.ui_lua_patch_context_post_setup_view_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_set_active_enabled_list: self.ui_lua_patch_context_set_active_enabled_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_set_active_disabled_list: self.ui_lua_patch_context_set_active_disabled_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_destroy_list: self.ui_lua_patch_context_destroy_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_destroy_force_list: self.ui_lua_patch_context_destroy_force_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_button_map: self.ui_lua_patch_context_button_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_input_field_map: self.ui_lua_patch_context_input_field_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_drowdown_map: self.ui_lua_patch_context_drowdown_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_toggle_map: self.ui_lua_patch_context_toggle_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_slider_map: self.ui_lua_patch_context_slider_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ui_lua_patch_context_panel_map: self.ui_lua_patch_context_panel_map = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ui_lua_patch_context_button_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_button_map'): return self._m_has_field_ui_lua_patch_context_button_map self._m_has_field_ui_lua_patch_context_button_map = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_button_map', None) @property def has_field_ui_lua_patch_context_set_active_disabled_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_set_active_disabled_list'): return self._m_has_field_ui_lua_patch_context_set_active_disabled_list self._m_has_field_ui_lua_patch_context_set_active_disabled_list = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_set_active_disabled_list', None) @property def has_field_enable_all_context_lua_patch(self): if hasattr(self, '_m_has_field_enable_all_context_lua_patch'): return self._m_has_field_enable_all_context_lua_patch self._m_has_field_enable_all_context_lua_patch = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_enable_all_context_lua_patch', None) @property def has_field_ui_lua_patch_context_setup_view_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_setup_view_list'): return self._m_has_field_ui_lua_patch_context_setup_view_list self._m_has_field_ui_lua_patch_context_setup_view_list = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_setup_view_list', None) @property def has_field_ui_lua_patch_context_destroy_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_destroy_list'): return self._m_has_field_ui_lua_patch_context_destroy_list self._m_has_field_ui_lua_patch_context_destroy_list = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_destroy_list', None) @property def has_field_enable_lua_patch(self): if hasattr(self, '_m_has_field_enable_lua_patch'): return self._m_has_field_enable_lua_patch self._m_has_field_enable_lua_patch = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_enable_lua_patch', None) @property def has_field_ui_lua_patch_context_slider_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_slider_map'): return self._m_has_field_ui_lua_patch_context_slider_map self._m_has_field_ui_lua_patch_context_slider_map = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_slider_map', None) @property def has_field_ui_lua_patch_context_input_field_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_input_field_map'): return self._m_has_field_ui_lua_patch_context_input_field_map self._m_has_field_ui_lua_patch_context_input_field_map = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_input_field_map', None) @property def has_field_ui_lua_patch_context_panel_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_panel_map'): return self._m_has_field_ui_lua_patch_context_panel_map self._m_has_field_ui_lua_patch_context_panel_map = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_panel_map', None) @property def has_field_ui_lua_patch_context_destroy_force_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_destroy_force_list'): return self._m_has_field_ui_lua_patch_context_destroy_force_list self._m_has_field_ui_lua_patch_context_destroy_force_list = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_destroy_force_list', None) @property def has_field_ui_lua_patch_context_set_active_enabled_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_set_active_enabled_list'): return self._m_has_field_ui_lua_patch_context_set_active_enabled_list self._m_has_field_ui_lua_patch_context_set_active_enabled_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_set_active_enabled_list', None) @property def has_field_ui_lua_patch_context_post_setup_view_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_post_setup_view_list'): return self._m_has_field_ui_lua_patch_context_post_setup_view_list self._m_has_field_ui_lua_patch_context_post_setup_view_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_post_setup_view_list', None) @property def has_field_ui_lua_patch_context_drowdown_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_drowdown_map'): return self._m_has_field_ui_lua_patch_context_drowdown_map self._m_has_field_ui_lua_patch_context_drowdown_map = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_drowdown_map', None) @property def has_field_ui_lua_patch_context_toggle_map(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_toggle_map'): return self._m_has_field_ui_lua_patch_context_toggle_map self._m_has_field_ui_lua_patch_context_toggle_map = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_toggle_map', None) @property def has_field_ui_lua_script_path(self): if hasattr(self, '_m_has_field_ui_lua_script_path'): return self._m_has_field_ui_lua_script_path self._m_has_field_ui_lua_script_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_ui_lua_script_path', None) @property def has_field_ui_lua_patch_context_startup_list(self): if hasattr(self, '_m_has_field_ui_lua_patch_context_startup_list'): return self._m_has_field_ui_lua_patch_context_startup_list self._m_has_field_ui_lua_patch_context_startup_list = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_ui_lua_patch_context_startup_list', None) class ConfigAttackProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_damage_percentage: self.damage_percentage = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_damage_percentage_ratio: self.damage_percentage_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_element_rank: self.element_rank = self._io.read_f4le() if self.has_field_element_durability: self.element_durability = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_override_by_weapon: self.override_by_weapon = self._io.read_u1() if self.has_field_ignore_attacker_property: self.ignore_attacker_property = self._io.read_u1() if self.has_field_strike_type: self.strike_type = Output.EnumStrikeType(self._io, self, self._root) if self.has_field_en_break: self.en_break = self._io.read_f4le() if self.has_field_en_head_break: self.en_head_break = self._io.read_f4le() if self.has_field_attack_type: self.attack_type = Output.EnumAttackType(self._io, self, self._root) if self.has_field_damage_extra: self.damage_extra = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_bonus_critical: self.bonus_critical = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_bonus_critical_hurt: self.bonus_critical_hurt = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_ignore_level_diff: self.ignore_level_diff = self._io.read_u1() if self.has_field_true_damage: self.true_damage = self._io.read_u1() if self.has_field_ignore_modify_damage: self.ignore_modify_damage = self._io.read_u1() @property def has_field_bonus_critical_hurt(self): if hasattr(self, '_m_has_field_bonus_critical_hurt'): return self._m_has_field_bonus_critical_hurt self._m_has_field_bonus_critical_hurt = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_bonus_critical_hurt', None) @property def has_field_ignore_level_diff(self): if hasattr(self, '_m_has_field_ignore_level_diff'): return self._m_has_field_ignore_level_diff self._m_has_field_ignore_level_diff = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_ignore_level_diff', None) @property def has_field_element_rank(self): if hasattr(self, '_m_has_field_element_rank'): return self._m_has_field_element_rank self._m_has_field_element_rank = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_element_rank', None) @property def has_field_damage_extra(self): if hasattr(self, '_m_has_field_damage_extra'): return self._m_has_field_damage_extra self._m_has_field_damage_extra = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_damage_extra', None) @property def has_field_ignore_modify_damage(self): if hasattr(self, '_m_has_field_ignore_modify_damage'): return self._m_has_field_ignore_modify_damage self._m_has_field_ignore_modify_damage = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_ignore_modify_damage', None) @property def has_field_ignore_attacker_property(self): if hasattr(self, '_m_has_field_ignore_attacker_property'): return self._m_has_field_ignore_attacker_property self._m_has_field_ignore_attacker_property = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ignore_attacker_property', None) @property def has_field_true_damage(self): if hasattr(self, '_m_has_field_true_damage'): return self._m_has_field_true_damage self._m_has_field_true_damage = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_true_damage', None) @property def has_field_bonus_critical(self): if hasattr(self, '_m_has_field_bonus_critical'): return self._m_has_field_bonus_critical self._m_has_field_bonus_critical = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_bonus_critical', None) @property def has_field_damage_percentage(self): if hasattr(self, '_m_has_field_damage_percentage'): return self._m_has_field_damage_percentage self._m_has_field_damage_percentage = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_damage_percentage', None) @property def has_field_override_by_weapon(self): if hasattr(self, '_m_has_field_override_by_weapon'): return self._m_has_field_override_by_weapon self._m_has_field_override_by_weapon = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_override_by_weapon', None) @property def has_field_attack_type(self): if hasattr(self, '_m_has_field_attack_type'): return self._m_has_field_attack_type self._m_has_field_attack_type = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_attack_type', None) @property def has_field_en_head_break(self): if hasattr(self, '_m_has_field_en_head_break'): return self._m_has_field_en_head_break self._m_has_field_en_head_break = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_en_head_break', None) @property def has_field_damage_percentage_ratio(self): if hasattr(self, '_m_has_field_damage_percentage_ratio'): return self._m_has_field_damage_percentage_ratio self._m_has_field_damage_percentage_ratio = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_damage_percentage_ratio', None) @property def has_field_strike_type(self): if hasattr(self, '_m_has_field_strike_type'): return self._m_has_field_strike_type self._m_has_field_strike_type = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_strike_type', None) @property def has_field_element_durability(self): if hasattr(self, '_m_has_field_element_durability'): return self._m_has_field_element_durability self._m_has_field_element_durability = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_element_durability', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_en_break(self): if hasattr(self, '_m_has_field_en_break'): return self._m_has_field_en_break self._m_has_field_en_break = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_en_break', None) class SalvageTypeDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGroupLinksExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_link_id: self.link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_set_list: self.set_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_link_id(self): if hasattr(self, '_m_has_field_link_id'): return self._m_has_field_link_id self._m_has_field_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_link_id', None) @property def has_field_set_list(self): if hasattr(self, '_m_has_field_set_list'): return self._m_has_field_set_list self._m_has_field_set_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_set_list', None) class DropSubfieldEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_subfield_id: self.drop_subfield_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_drop_subfield_id(self): if hasattr(self, '_m_has_field_drop_subfield_id'): return self._m_has_field_drop_subfield_id self._m_has_field_drop_subfield_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_drop_subfield_id', None) class AsterActivityPerviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MonsterCurveExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_curve_infos: self.curve_infos = Output.ArrayOfGrowCurveInfoLengthS(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_curve_infos(self): if hasattr(self, '_m_has_field_curve_infos'): return self._m_has_field_curve_infos self._m_has_field_curve_infos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_curve_infos', None) class EnumPlaceNameActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlaceNameActionType, self.data.value) return getattr(self, '_m_value', None) class MusicEnemySettings(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_entity_id: self.entity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_state_value: self.main_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_aux_state_group: self.aux_state_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_default_aux_state_value: self.default_aux_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_combat_phase_states: self.combat_phase_states = Output.ArrayOfMusicEnemyCombatPhaseStateLengthU(self._io, self, self._root) @property def has_field_entity_id(self): if hasattr(self, '_m_has_field_entity_id'): return self._m_has_field_entity_id self._m_has_field_entity_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entity_id', None) @property def has_field_main_state_value(self): if hasattr(self, '_m_has_field_main_state_value'): return self._m_has_field_main_state_value self._m_has_field_main_state_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_main_state_value', None) @property def has_field_default_aux_state_value(self): if hasattr(self, '_m_has_field_default_aux_state_value'): return self._m_has_field_default_aux_state_value self._m_has_field_default_aux_state_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_aux_state_value', None) @property def has_field_aux_state_group(self): if hasattr(self, '_m_has_field_aux_state_group'): return self._m_has_field_aux_state_group self._m_has_field_aux_state_group = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_aux_state_group', None) @property def has_field_combat_phase_states(self): if hasattr(self, '_m_has_field_combat_phase_states'): return self._m_has_field_combat_phase_states self._m_has_field_combat_phase_states = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_combat_phase_states', None) class ArrayOfConfigPointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigPoint(self._io, self, self._root)) class DictOfAuxTypesStringConfigActionTokenChannelGroupInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigActionTokenChannelGroupInfo(self._io, self, self._root)) class ConfigHomeAnimal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spawn_pos: self.spawn_pos = Output.Vector(self._io, self, self._root) if self.has_field_spawn_rot: self.spawn_rot = Output.Vector(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_spawn_pos(self): if hasattr(self, '_m_has_field_spawn_pos'): return self._m_has_field_spawn_pos self._m_has_field_spawn_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_pos', None) @property def has_field_spawn_rot(self): if hasattr(self, '_m_has_field_spawn_rot'): return self._m_has_field_spawn_rot self._m_has_field_spawn_rot = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_spawn_rot', None) class ArrayOfConfigSpatialBoxRoomTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSpatialBoxRoomTrigger(self._io, self, self._root)) class EchoShellRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shell_count: self.shell_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_at_top: self.show_at_top = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_shell_count(self): if hasattr(self, '_m_has_field_shell_count'): return self._m_has_field_shell_count self._m_has_field_shell_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_shell_count', None) @property def has_field_show_at_top(self): if hasattr(self, '_m_has_field_show_at_top'): return self._m_has_field_show_at_top self._m_has_field_show_at_top = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_show_at_top', None) class EnumStandDirection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StandDirection, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumConfigWeatherTypeArrayOfEnumNeuronNameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumConfigWeatherType(self._io, self, self._root) self.value = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) class ArrayOfSignInCondConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SignInCondConfig(self._io, self, self._root)) class HandbookQuestGuideShowCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumHandbookQuestGuideShowCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class EnumBlossomShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlossomShowType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfDispConfigControlPartLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigControlPart(self._io, self, self._root)) class ShopmallRecommendCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AsterMidDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_world_level_vec: self.world_level_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resin: self.resin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_world_level_vec(self): if hasattr(self, '_m_has_field_world_level_vec'): return self._m_has_field_world_level_vec self._m_has_field_world_level_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_world_level_vec', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_resin(self): if hasattr(self, '_m_has_field_resin'): return self._m_has_field_resin self._m_has_field_resin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_resin', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class KvpOfDictEnumVolatileTypeConfigGraphicsVolatileSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumVolatileType(self._io, self, self._root) self.value = Output.ConfigGraphicsVolatileSetting(self._io, self, self._root) class GatherAreaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumAvatarIdentityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AvatarIdentityType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetStateSetAnimInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_int_id: self.int_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_sync_state: self.sync_state = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) @property def has_field_int_id(self): if hasattr(self, '_m_has_field_int_id'): return self._m_has_field_int_id self._m_has_field_int_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_id', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def has_field_sync_state(self): if hasattr(self, '_m_has_field_sync_state'): return self._m_has_field_sync_state self._m_has_field_sync_state = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sync_state', None) class ArrayOfMusicEnemyCombatPhaseStateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MusicEnemyCombatPhaseState(self._io, self, self._root)) class ConfigAiExtractionSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiExtractionData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiExtractionData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class AvatarExitViewBias(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lerp_duration: self.lerp_duration = self._io.read_f4le() if self.has_field_lerp_radius: self.lerp_radius = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_lerp_radius(self): if hasattr(self, '_m_has_field_lerp_radius'): return self._m_has_field_lerp_radius self._m_has_field_lerp_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lerp_radius', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_lerp_duration(self): if hasattr(self, '_m_has_field_lerp_duration'): return self._m_has_field_lerp_duration self._m_has_field_lerp_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lerp_duration', None) class IrodoriFlowerConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_slot_identifier: self.slot_identifier = AuxTypes.String(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_slot_identifier(self): if hasattr(self, '_m_has_field_slot_identifier'): return self._m_has_field_slot_identifier self._m_has_field_slot_identifier = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_slot_identifier', None) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_id', None) class EnumPersonalLineActivityFeature(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PersonalLineActivityFeature, self.data.value) return getattr(self, '_m_value', None) class ByHasElement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element: self.element = Output.EnumElementType(self._io, self, self._root) @property def has_field_element(self): if hasattr(self, '_m_has_field_element'): return self._m_has_field_element self._m_has_field_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class RegionSearchRecycleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeOverallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPaimonRequestFrom(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PaimonRequestFrom, self.data.value) return getattr(self, '_m_value', None) class AbilityCommonLocalId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActivityBannerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityBannerType, self.data.value) return getattr(self, '_m_value', None) class ViewCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_image: self.image = AuxTypes.String(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_world_area_id: self.world_area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() if self.has_field_show_only_unlocked: self.show_only_unlocked = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_world_area_id(self): if hasattr(self, '_m_has_field_world_area_id'): return self._m_has_field_world_area_id self._m_has_field_world_area_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_world_area_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_show_only_unlocked(self): if hasattr(self, '_m_has_field_show_only_unlocked'): return self._m_has_field_show_only_unlocked self._m_has_field_show_only_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_show_only_unlocked', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_image(self): if hasattr(self, '_m_has_field_image'): return self._m_has_field_image self._m_has_field_image = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_image', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigRecordFrame(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_delta_time: self.delta_time = self._io.read_f4le() if self.has_field_frame_count: self.frame_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_actors: self.actors = Output.ArrayOfDispConfigRecordActorBaseLengthU(self._io, self, self._root) @property def has_field_delta_time(self): if hasattr(self, '_m_has_field_delta_time'): return self._m_has_field_delta_time self._m_has_field_delta_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_delta_time', None) @property def has_field_frame_count(self): if hasattr(self, '_m_has_field_frame_count'): return self._m_has_field_frame_count self._m_has_field_frame_count = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_frame_count', None) @property def has_field_actors(self): if hasattr(self, '_m_has_field_actors'): return self._m_has_field_actors self._m_has_field_actors = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_actors', None) class BuoyantCombatLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabLoopDungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CampExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trophic_level: self.trophic_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enemy_camp_list: self.enemy_camp_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_trophic_level(self): if hasattr(self, '_m_has_field_trophic_level'): return self._m_has_field_trophic_level self._m_has_field_trophic_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_trophic_level', None) @property def has_field_enemy_camp_list(self): if hasattr(self, '_m_has_field_enemy_camp_list'): return self._m_has_field_enemy_camp_list self._m_has_field_enemy_camp_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_enemy_camp_list', None) class ConfigAiFishingBitesBaitSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFishingBitesBaitData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFishingBitesBaitData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class BargainExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomTalkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExhibitionCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NpcFirstMetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_quest_id_list: self.sub_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_description: self.avatar_description = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sub_quest_id_list(self): if hasattr(self, '_m_has_field_sub_quest_id_list'): return self._m_has_field_sub_quest_id_list self._m_has_field_sub_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sub_quest_id_list', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_avatar_description(self): if hasattr(self, '_m_has_field_avatar_description'): return self._m_has_field_avatar_description self._m_has_field_avatar_description = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_avatar_description', None) class EnumCookBonusType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CookBonusType, self.data.value) return getattr(self, '_m_value', None) class EnumPaimonSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PaimonSkill, self.data.value) return getattr(self, '_m_value', None) class ArrayOfH5activityCondConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.H5activityCondConfig(self._io, self, self._root)) class ConfigWidgetToyClintDetector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_allow_city_id: self.allow_city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_hint_group', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_allow_city_id(self): if hasattr(self, '_m_has_field_allow_city_id'): return self._m_has_field_allow_city_id self._m_has_field_allow_city_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_allow_city_id', None) class DictOfAuxTypesVlqBase128LeSConfigAiMeleeChargeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiMeleeChargeData(self._io, self, self._root)) class EnumBonusSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BonusSourceType, self.data.value) return getattr(self, '_m_value', None) class ActorBornRelativePosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReunionMissionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_group_id: self.watcher_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_score: self.target_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_reward_id: self.finish_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_score_list: self.target_score_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_finish_reward_id_list: self.finish_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_reward_id_list: self.show_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_show_reward_id_list(self): if hasattr(self, '_m_has_field_show_reward_id_list'): return self._m_has_field_show_reward_id_list self._m_has_field_show_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_reward_id_list', None) @property def has_field_finish_reward_id(self): if hasattr(self, '_m_has_field_finish_reward_id'): return self._m_has_field_finish_reward_id self._m_has_field_finish_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_finish_reward_id', None) @property def has_field_target_score_list(self): if hasattr(self, '_m_has_field_target_score_list'): return self._m_has_field_target_score_list self._m_has_field_target_score_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_target_score_list', None) @property def has_field_finish_reward_id_list(self): if hasattr(self, '_m_has_field_finish_reward_id_list'): return self._m_has_field_finish_reward_id_list self._m_has_field_finish_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_finish_reward_id_list', None) @property def has_field_watcher_group_id(self): if hasattr(self, '_m_has_field_watcher_group_id'): return self._m_has_field_watcher_group_id self._m_has_field_watcher_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_watcher_group_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_target_score(self): if hasattr(self, '_m_has_field_target_score'): return self._m_has_field_target_score self._m_has_field_target_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_target_score', None) class TargetIndicatorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeAvatarEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityChessScheduleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_day: self.day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp_up_limit: self.exp_up_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_map_list: self.open_map_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_day(self): if hasattr(self, '_m_has_field_day'): return self._m_has_field_day self._m_has_field_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_day', None) @property def has_field_exp_up_limit(self): if hasattr(self, '_m_has_field_exp_up_limit'): return self._m_has_field_exp_up_limit self._m_has_field_exp_up_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_exp_up_limit', None) @property def has_field_open_map_list(self): if hasattr(self, '_m_has_field_open_map_list'): return self._m_has_field_open_map_list self._m_has_field_open_map_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_map_list', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cond_id', None) class EnumCcdType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CcdType, self.data.value) return getattr(self, '_m_value', None) class IndicatorCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigJudgeCurrentTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_start_time: self.start_time = self._io.read_f4le() if self.has_field_end_time: self.end_time = self._io.read_f4le() @property def has_field_start_time(self): if hasattr(self, '_m_has_field_start_time'): return self._m_has_field_start_time self._m_has_field_start_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start_time', None) @property def has_field_end_time(self): if hasattr(self, '_m_has_field_end_time'): return self._m_has_field_end_time self._m_has_field_end_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_end_time', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class ArrayOfEnumConfigWeatherTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumConfigWeatherType(self._io, self, self._root)) class ArrayOfEnumEnvZoneEventTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumEnvZoneEventType(self._io, self, self._root)) class WinterCampBattleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiBrownianMotionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_move_cd_min: self.move_cd_min = self._io.read_f4le() if self.has_field_move_cd_max: self.move_cd_max = self._io.read_f4le() if self.has_field_terrain_offset_min: self.terrain_offset_min = self._io.read_f4le() if self.has_field_terrain_offset_max: self.terrain_offset_max = self._io.read_f4le() if self.has_field_motion_radius: self.motion_radius = self._io.read_f4le() if self.has_field_recalc_center_on_leave_current_zone: self.recalc_center_on_leave_current_zone = self._io.read_u1() if self.has_field_recalc_center_on_attach_pos_change: self.recalc_center_on_attach_pos_change = self._io.read_u1() @property def has_field_terrain_offset_min(self): if hasattr(self, '_m_has_field_terrain_offset_min'): return self._m_has_field_terrain_offset_min self._m_has_field_terrain_offset_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_terrain_offset_min', None) @property def has_field_move_cd_max(self): if hasattr(self, '_m_has_field_move_cd_max'): return self._m_has_field_move_cd_max self._m_has_field_move_cd_max = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_move_cd_max', None) @property def has_field_recalc_center_on_leave_current_zone(self): if hasattr(self, '_m_has_field_recalc_center_on_leave_current_zone'): return self._m_has_field_recalc_center_on_leave_current_zone self._m_has_field_recalc_center_on_leave_current_zone = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_recalc_center_on_leave_current_zone', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_motion_radius(self): if hasattr(self, '_m_has_field_motion_radius'): return self._m_has_field_motion_radius self._m_has_field_motion_radius = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_motion_radius', None) @property def has_field_recalc_center_on_attach_pos_change(self): if hasattr(self, '_m_has_field_recalc_center_on_attach_pos_change'): return self._m_has_field_recalc_center_on_attach_pos_change self._m_has_field_recalc_center_on_attach_pos_change = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_recalc_center_on_attach_pos_change', None) @property def has_field_terrain_offset_max(self): if hasattr(self, '_m_has_field_terrain_offset_max'): return self._m_has_field_terrain_offset_max self._m_has_field_terrain_offset_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_terrain_offset_max', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) @property def has_field_move_cd_min(self): if hasattr(self, '_m_has_field_move_cd_min'): return self._m_has_field_move_cd_min self._m_has_field_move_cd_min = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_move_cd_min', None) class ByTargetIsCaster(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_caster: self.is_caster = self._io.read_u1() @property def has_field_is_caster(self): if hasattr(self, '_m_has_field_is_caster'): return self._m_has_field_is_caster self._m_has_field_is_caster = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_caster', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ContextActionSelectChapterOngoingMainQuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_chapter_id', None) class EnumLunaRiteRegionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LunaRiteRegionType, self.data.value) return getattr(self, '_m_value', None) class ChannellerSlabLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDragonSpinePhase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DragonSpinePhase, self.data.value) return getattr(self, '_m_value', None) class EnumGuideAvatarState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideAvatarState, self.data.value) return getattr(self, '_m_value', None) class BinaryClipInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AddGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_random_in_range: self.random_in_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def has_field_random_in_range(self): if hasattr(self, '_m_has_field_random_in_range'): return self._m_has_field_random_in_range self._m_has_field_random_in_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_in_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SingleTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_target_predicates: self.target_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target', None) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_target_predicates(self): if hasattr(self, '_m_has_field_target_predicates'): return self._m_has_field_target_predicates self._m_has_field_target_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_predicates', None) class EnumEntityTokenActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityTokenActionType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringAuxTypesVlqBase128LeU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAuxTypesVlqBase128LeU(self._io, self, self._root)) class EnumHpBarStyle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HpBarStyle, self.data.value) return getattr(self, '_m_value', None) class RogueDiaryBuffTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCloseGpuCullingInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfConfigGadgetConsolePositionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetConsolePosition(self._io, self, self._root)) class KvpOfDictAuxTypesStringPlayerCustomOptionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.PlayerCustomOptionConfig(self._io, self, self._root) class ConfigFlycloakFashionScale(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_male: self.male = self._io.read_f4le() if self.has_field_lady: self.lady = self._io.read_f4le() if self.has_field_boy: self.boy = self._io.read_f4le() if self.has_field_girl: self.girl = self._io.read_f4le() if self.has_field_loli: self.loli = self._io.read_f4le() @property def has_field_girl(self): if hasattr(self, '_m_has_field_girl'): return self._m_has_field_girl self._m_has_field_girl = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_girl', None) @property def has_field_boy(self): if hasattr(self, '_m_has_field_boy'): return self._m_has_field_boy self._m_has_field_boy = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_boy', None) @property def has_field_loli(self): if hasattr(self, '_m_has_field_loli'): return self._m_has_field_loli self._m_has_field_loli = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_loli', None) @property def has_field_male(self): if hasattr(self, '_m_has_field_male'): return self._m_has_field_male self._m_has_field_male = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_male', None) @property def has_field_lady(self): if hasattr(self, '_m_has_field_lady'): return self._m_has_field_lady self._m_has_field_lady = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lady', None) class ActivityPhotographPosExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiFollowScriptedPathData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFollowScriptedPathData(self._io, self, self._root)) class ConfigGadgetConsoleLimitation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trans_name: self.trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_move_type: self.move_type = Output.EnumConfigGadgetConsoleOperationType(self._io, self, self._root) if self.has_field_has_min: self.has_min = self._io.read_u1() if self.has_field_min: self.min = self._io.read_f4le() if self.has_field_has_max: self.has_max = self._io.read_u1() if self.has_field_max: self.max = self._io.read_f4le() @property def has_field_trans_name(self): if hasattr(self, '_m_has_field_trans_name'): return self._m_has_field_trans_name self._m_has_field_trans_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trans_name', None) @property def has_field_has_min(self): if hasattr(self, '_m_has_field_has_min'): return self._m_has_field_has_min self._m_has_field_has_min = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_has_min', None) @property def has_field_max(self): if hasattr(self, '_m_has_field_max'): return self._m_has_field_max self._m_has_field_max = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_max', None) @property def has_field_has_max(self): if hasattr(self, '_m_has_field_has_max'): return self._m_has_field_has_max self._m_has_field_has_max = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_has_max', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_move_type', None) @property def has_field_min(self): if hasattr(self, '_m_has_field_min'): return self._m_has_field_min self._m_has_field_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min', None) class ArrayOfConfigAnimatorBooleanLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAnimatorBoolean(self._io, self, self._root)) class RewardPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigVCustomMapMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigVMapMark(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_custom_type: self.custom_type = Output.EnumMarkCustomType(self._io, self, self._root) @property def visible_type_level_map(self): if hasattr(self, '_m_visible_type_level_map'): return self._m_visible_type_level_map self._m_visible_type_level_map = self.base.visible_type_level_map return getattr(self, '_m_visible_type_level_map', None) @property def has_field_custom_type(self): if hasattr(self, '_m_has_field_custom_type'): return self._m_has_field_custom_type self._m_has_field_custom_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_type', None) @property def visible_type_mini_map(self): if hasattr(self, '_m_visible_type_mini_map'): return self._m_visible_type_mini_map self._m_visible_type_mini_map = self.base.visible_type_mini_map return getattr(self, '_m_visible_type_mini_map', None) @property def res_path(self): if hasattr(self, '_m_res_path'): return self._m_res_path self._m_res_path = self.base.res_path return getattr(self, '_m_res_path', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def layer_type(self): if hasattr(self, '_m_layer_type'): return self._m_layer_type self._m_layer_type = self.base.layer_type return getattr(self, '_m_layer_type', None) class EnumFightPropType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FightPropType, self.data.value) return getattr(self, '_m_value', None) class PropTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReactionEnergyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumElementReactionType(self._io, self, self._root) if self.has_field_min_durability: self.min_durability = self._io.read_f4le() if self.has_field_max_durability: self.max_durability = self._io.read_f4le() if self.has_field_cost_ratio: self.cost_ratio = self._io.read_f4le() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_size: self.pool_size = self._io.read_f4le() if self.has_field_pool_revive_period: self.pool_revive_period = self._io.read_f4le() if self.has_field_pool_revive_energy: self.pool_revive_energy = self._io.read_f4le() if self.has_field_is_persistent: self.is_persistent = self._io.read_u1() if self.has_field_cost_period: self.cost_period = self._io.read_f4le() if self.has_field_drop_prob: self.drop_prob = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_pool_revive_energy(self): if hasattr(self, '_m_has_field_pool_revive_energy'): return self._m_has_field_pool_revive_energy self._m_has_field_pool_revive_energy = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_pool_revive_energy', None) @property def has_field_max_durability(self): if hasattr(self, '_m_has_field_max_durability'): return self._m_has_field_max_durability self._m_has_field_max_durability = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_durability', None) @property def has_field_cost_ratio(self): if hasattr(self, '_m_has_field_cost_ratio'): return self._m_has_field_cost_ratio self._m_has_field_cost_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cost_ratio', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_is_persistent(self): if hasattr(self, '_m_has_field_is_persistent'): return self._m_has_field_is_persistent self._m_has_field_is_persistent = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_persistent', None) @property def has_field_drop_prob(self): if hasattr(self, '_m_has_field_drop_prob'): return self._m_has_field_drop_prob self._m_has_field_drop_prob = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_drop_prob', None) @property def has_field_cost_period(self): if hasattr(self, '_m_has_field_cost_period'): return self._m_has_field_cost_period self._m_has_field_cost_period = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cost_period', None) @property def has_field_pool_revive_period(self): if hasattr(self, '_m_has_field_pool_revive_period'): return self._m_has_field_pool_revive_period self._m_has_field_pool_revive_period = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_pool_revive_period', None) @property def has_field_pool_size(self): if hasattr(self, '_m_has_field_pool_size'): return self._m_has_field_pool_size self._m_has_field_pool_size = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pool_size', None) @property def has_field_min_durability(self): if hasattr(self, '_m_has_field_min_durability'): return self._m_has_field_min_durability self._m_has_field_min_durability = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_min_durability', None) class EnumClimateTrendType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ClimateTrendType, self.data.value) return getattr(self, '_m_value', None) class SetPaimonLookAtCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_: self.from_ = Output.EnumPaimonRequestFrom(self._io, self, self._root) if self.has_field_lookat: self.lookat = self._io.read_u1() if self.has_field_min_time: self.min_time = self._io.read_f4le() if self.has_field_max_time: self.max_time = self._io.read_f4le() @property def has_field_min_time(self): if hasattr(self, '_m_has_field_min_time'): return self._m_has_field_min_time self._m_has_field_min_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_time', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_max_time(self): if hasattr(self, '_m_has_field_max_time'): return self._m_has_field_max_time self._m_has_field_max_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_time', None) @property def has_field_lookat(self): if hasattr(self, '_m_has_field_lookat'): return self._m_has_field_lookat self._m_has_field_lookat = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lookat', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_from_(self): if hasattr(self, '_m_has_field_from_'): return self._m_has_field_from_ self._m_has_field_from_ = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_', None) class RoguelikeCursePoolExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sequence_id: self.sequence_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sequence_id(self): if hasattr(self, '_m_has_field_sequence_id'): return self._m_has_field_sequence_id self._m_has_field_sequence_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sequence_id', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_pool_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) class ArrayOfContextConditionActionGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ContextConditionActionGroup(self._io, self, self._root)) class GroupLinksBundleRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUF4(self._io, self, self._root)) class RogueGadgetStateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalkRoleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RewardTransformConfigProxy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BornRandomFromCenter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.BornRandom(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_min_random_range: self.min_random_range = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_random_range: self.max_random_range = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_min_random_range(self): if hasattr(self, '_m_has_field_min_random_range'): return self._m_has_field_min_random_range self._m_has_field_min_random_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_random_range', None) @property def has_field_max_random_range(self): if hasattr(self, '_m_has_field_max_random_range'): return self._m_has_field_max_random_range self._m_has_field_max_random_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_random_range', None) class ConfigContentRestriction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_country_code: self.country_code = AuxTypes.String(self._io, self, self._root) if self.has_field_age: self.age = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_country_code(self): if hasattr(self, '_m_has_field_country_code'): return self._m_has_field_country_code self._m_has_field_country_code = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_country_code', None) @property def has_field_age(self): if hasattr(self, '_m_has_field_age'): return self._m_has_field_age self._m_has_field_age = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_age', None) class RogueDiaryBuffEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfSceneTagCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SceneTagCond(self._io, self, self._root)) class DeviceAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_keyboard_touch: self.keyboard_touch = AuxTypes.String(self._io, self, self._root) if self.has_field_keyboard_mouse: self.keyboard_mouse = AuxTypes.String(self._io, self, self._root) if self.has_field_joypad: self.joypad = AuxTypes.String(self._io, self, self._root) @property def has_field_keyboard_touch(self): if hasattr(self, '_m_has_field_keyboard_touch'): return self._m_has_field_keyboard_touch self._m_has_field_keyboard_touch = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_keyboard_touch', None) @property def has_field_keyboard_mouse(self): if hasattr(self, '_m_has_field_keyboard_mouse'): return self._m_has_field_keyboard_mouse self._m_has_field_keyboard_mouse = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_keyboard_mouse', None) @property def has_field_joypad(self): if hasattr(self, '_m_has_field_joypad'): return self._m_has_field_joypad self._m_has_field_joypad = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_joypad', None) class ChannellerSlabBuffQualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHitImpulse(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hit_level: self.hit_level = Output.EnumHitLevel(self._io, self, self._root) if self.has_field_hit_impulse_x: self.hit_impulse_x = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_hit_impulse_y: self.hit_impulse_y = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_hit_level(self): if hasattr(self, '_m_has_field_hit_level'): return self._m_has_field_hit_level self._m_has_field_hit_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_level', None) @property def has_field_hit_impulse_x(self): if hasattr(self, '_m_has_field_hit_impulse_x'): return self._m_has_field_hit_impulse_x self._m_has_field_hit_impulse_x = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hit_impulse_x', None) @property def has_field_hit_impulse_y(self): if hasattr(self, '_m_has_field_hit_impulse_y'): return self._m_has_field_hit_impulse_y self._m_has_field_hit_impulse_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_hit_impulse_y', None) class HomeWorldLeastShopExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBowData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bow_ratio_name: self.bow_ratio_name = AuxTypes.String(self._io, self, self._root) if self.has_field_bow_string_loose_point: self.bow_string_loose_point = Output.Vector(self._io, self, self._root) if self.has_field_bow_string_max_len: self.bow_string_max_len = self._io.read_f4le() @property def has_field_bow_ratio_name(self): if hasattr(self, '_m_has_field_bow_ratio_name'): return self._m_has_field_bow_ratio_name self._m_has_field_bow_ratio_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bow_ratio_name', None) @property def has_field_bow_string_loose_point(self): if hasattr(self, '_m_has_field_bow_string_loose_point'): return self._m_has_field_bow_string_loose_point self._m_has_field_bow_string_loose_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bow_string_loose_point', None) @property def has_field_bow_string_max_len(self): if hasattr(self, '_m_has_field_bow_string_max_len'): return self._m_has_field_bow_string_max_len self._m_has_field_bow_string_max_len = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_bow_string_max_len', None) class FirstPersonCoopCamConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cam_position_offset: self.cam_position_offset = Output.Vector(self._io, self, self._root) if self.has_field_cam_target_offset: self.cam_target_offset = Output.Vector(self._io, self, self._root) if self.has_field_cam_fov: self.cam_fov = self._io.read_f4le() @property def has_field_cam_position_offset(self): if hasattr(self, '_m_has_field_cam_position_offset'): return self._m_has_field_cam_position_offset self._m_has_field_cam_position_offset = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cam_position_offset', None) @property def has_field_cam_target_offset(self): if hasattr(self, '_m_has_field_cam_target_offset'): return self._m_has_field_cam_target_offset self._m_has_field_cam_target_offset = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cam_target_offset', None) @property def has_field_cam_fov(self): if hasattr(self, '_m_has_field_cam_fov'): return self._m_has_field_cam_fov self._m_has_field_cam_fov = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cam_fov', None) class ConfigCcd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumCcdType(self._io, self, self._root) if self.has_field_detect_cd: self.detect_cd = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_detect_cd(self): if hasattr(self, '_m_has_field_detect_cd'): return self._m_has_field_detect_cd self._m_has_field_detect_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_cd', None) class ActorEvtTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialAvatarDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetMaterialParamFloatByTransform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mat_name: self.mat_name = AuxTypes.String(self._io, self, self._root) if self.has_field_pattern_name: self.pattern_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_use_curve: self.use_curve = self._io.read_u1() if self.has_field_lerp_curve_index: self.lerp_curve_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lerp_time: self.lerp_time = self._io.read_f4le() @property def has_field_lerp_curve_index(self): if hasattr(self, '_m_has_field_lerp_curve_index'): return self._m_has_field_lerp_curve_index self._m_has_field_lerp_curve_index = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_lerp_curve_index', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_lerp_time(self): if hasattr(self, '_m_has_field_lerp_time'): return self._m_has_field_lerp_time self._m_has_field_lerp_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_lerp_time', None) @property def has_field_use_curve(self): if hasattr(self, '_m_has_field_use_curve'): return self._m_has_field_use_curve self._m_has_field_use_curve = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_curve', None) @property def has_field_mat_name(self): if hasattr(self, '_m_has_field_mat_name'): return self._m_has_field_mat_name self._m_has_field_mat_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mat_name', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_pattern_name(self): if hasattr(self, '_m_has_field_pattern_name'): return self._m_has_field_pattern_name self._m_has_field_pattern_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_pattern_name', None) class LanV2projectionLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrAttachStreamLayerRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EmojiDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HuntingMonsterGroupTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumAbilityStateAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumAbilityStateAuxTypesString(self._io, self, self._root)) class SystemValuerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed: self.speed = self._io.read_f4le() if self.has_field_max_speed: self.max_speed = self._io.read_f4le() if self.has_field_min_speed: self.min_speed = self._io.read_f4le() if self.has_field_angler_velocity: self.angler_velocity = self._io.read_f4le() if self.has_field_acceleration: self.acceleration = self._io.read_f4le() if self.has_field_acceleration_time: self.acceleration_time = self._io.read_f4le() if self.has_field_can_born_in_water: self.can_born_in_water = self._io.read_u1() if self.has_field_update_angle: self.update_angle = Output.DispConfigBulletMoveAngle(self._io, self, self._root) if self.has_field_delay: self.delay = self._io.read_f4le() if self.has_field_stick_to_ground: self.stick_to_ground = Output.ConfigMoveStickToGround(self._io, self, self._root) if self.has_field_sync_to_remote: self.sync_to_remote = self._io.read_u1() if self.has_field_blocked_by_monster_radius: self.blocked_by_monster_radius = self._io.read_f4le() @property def has_field_speed(self): if hasattr(self, '_m_has_field_speed'): return self._m_has_field_speed self._m_has_field_speed = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed', None) @property def has_field_update_angle(self): if hasattr(self, '_m_has_field_update_angle'): return self._m_has_field_update_angle self._m_has_field_update_angle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_update_angle', None) @property def has_field_sync_to_remote(self): if hasattr(self, '_m_has_field_sync_to_remote'): return self._m_has_field_sync_to_remote self._m_has_field_sync_to_remote = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_sync_to_remote', None) @property def has_field_max_speed(self): if hasattr(self, '_m_has_field_max_speed'): return self._m_has_field_max_speed self._m_has_field_max_speed = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_max_speed', None) @property def has_field_acceleration(self): if hasattr(self, '_m_has_field_acceleration'): return self._m_has_field_acceleration self._m_has_field_acceleration = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_acceleration', None) @property def has_field_blocked_by_monster_radius(self): if hasattr(self, '_m_has_field_blocked_by_monster_radius'): return self._m_has_field_blocked_by_monster_radius self._m_has_field_blocked_by_monster_radius = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_blocked_by_monster_radius', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_stick_to_ground(self): if hasattr(self, '_m_has_field_stick_to_ground'): return self._m_has_field_stick_to_ground self._m_has_field_stick_to_ground = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_stick_to_ground', None) @property def has_field_angler_velocity(self): if hasattr(self, '_m_has_field_angler_velocity'): return self._m_has_field_angler_velocity self._m_has_field_angler_velocity = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_angler_velocity', None) @property def has_field_can_born_in_water(self): if hasattr(self, '_m_has_field_can_born_in_water'): return self._m_has_field_can_born_in_water self._m_has_field_can_born_in_water = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_can_born_in_water', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_min_speed(self): if hasattr(self, '_m_has_field_min_speed'): return self._m_has_field_min_speed self._m_has_field_min_speed = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_min_speed', None) @property def has_field_delay(self): if hasattr(self, '_m_has_field_delay'): return self._m_has_field_delay self._m_has_field_delay = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_delay', None) @property def has_field_acceleration_time(self): if hasattr(self, '_m_has_field_acceleration_time'): return self._m_has_field_acceleration_time self._m_has_field_acceleration_time = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_acceleration_time', None) class EnumBlinkHitSceneTestType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlinkHitSceneTestType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideHasItemCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_id_lists: self.item_id_lists = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) if self.has_field_material_type_list: self.material_type_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGuideItemType(self._io, self, self._root) if self.has_field_not_have: self.not_have = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f4le() @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_material_type_list(self): if hasattr(self, '_m_has_field_material_type_list'): return self._m_has_field_material_type_list self._m_has_field_material_type_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_material_type_list', None) @property def has_field_not_have(self): if hasattr(self, '_m_has_field_not_have'): return self._m_has_field_not_have self._m_has_field_not_have = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_not_have', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def has_field_item_id_lists(self): if hasattr(self, '_m_has_field_item_id_lists'): return self._m_has_field_item_id_lists self._m_has_field_item_id_lists = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id_lists', None) class GuideWidgetSpecialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UlongIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriMasterMedalTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CookFoodTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRenderResolution(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_width: self.width = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_height: self.height = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_second_width: self.second_width = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_second_height: self.second_height = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_perf_cost_ratio: self.perf_cost_ratio = self._io.read_f4le() @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_second_height(self): if hasattr(self, '_m_has_field_second_height'): return self._m_has_field_second_height self._m_has_field_second_height = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_second_height', None) @property def has_field_width(self): if hasattr(self, '_m_has_field_width'): return self._m_has_field_width self._m_has_field_width = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_width', None) @property def has_field_second_width(self): if hasattr(self, '_m_has_field_second_width'): return self._m_has_field_second_width self._m_has_field_second_width = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_second_width', None) @property def has_field_perf_cost_ratio(self): if hasattr(self, '_m_has_field_perf_cost_ratio'): return self._m_has_field_perf_cost_ratio self._m_has_field_perf_cost_ratio = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_perf_cost_ratio', None) class AvatarIdentityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionBySelfElementReactionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_reaction_types: self.reaction_types = Output.ArrayOfEnumElementReactionTypeLengthU(self._io, self, self._root) if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_reaction_types(self): if hasattr(self, '_m_has_field_reaction_types'): return self._m_has_field_reaction_types self._m_has_field_reaction_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reaction_types', None) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigWidgetCdGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_under_time_scale: self.is_under_time_scale = self._io.read_u1() if self.has_field_cool_down_success: self.cool_down_success = self._io.read_f4le() if self.has_field_cool_down_fail: self.cool_down_fail = self._io.read_f4le() @property def has_field_is_under_time_scale(self): if hasattr(self, '_m_has_field_is_under_time_scale'): return self._m_has_field_is_under_time_scale self._m_has_field_is_under_time_scale = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_under_time_scale', None) @property def has_field_cool_down_success(self): if hasattr(self, '_m_has_field_cool_down_success'): return self._m_has_field_cool_down_success self._m_has_field_cool_down_success = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cool_down_success', None) @property def has_field_cool_down_fail(self): if hasattr(self, '_m_has_field_cool_down_fail'): return self._m_has_field_cool_down_fail self._m_has_field_cool_down_fail = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cool_down_fail', None) class DictOfEnumFadeTintQualityLevelConfigTintFadeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumFadeTintQualityLevelConfigTintFadeSetting(self._io, self, self._root)) class ArrayOfMainMonsterConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MainMonsterConfig(self._io, self, self._root)) class AnimatorRecordTransitionInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_transition_duration: self.transition_duration = self._io.read_f4le() if self.has_field_normalized_transition_time: self.normalized_transition_time = self._io.read_f4le() if self.has_field_duration_unit: self.duration_unit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_transition_duration(self): if hasattr(self, '_m_has_field_transition_duration'): return self._m_has_field_transition_duration self._m_has_field_transition_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_transition_duration', None) @property def has_field_normalized_transition_time(self): if hasattr(self, '_m_has_field_normalized_transition_time'): return self._m_has_field_normalized_transition_time self._m_has_field_normalized_transition_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_normalized_transition_time', None) @property def has_field_duration_unit(self): if hasattr(self, '_m_has_field_duration_unit'): return self._m_has_field_duration_unit self._m_has_field_duration_unit = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration_unit', None) class GivingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPhotographTaskType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PhotographTaskType, self.data.value) return getattr(self, '_m_value', None) class ActionBtnTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySpiceGivingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SelectTargetsSortTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideTeamMemberCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_member: self.has_member = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_has_member(self): if hasattr(self, '_m_has_field_has_member'): return self._m_has_field_has_member self._m_has_field_has_member = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_has_member', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class BanEntityMarkMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class SceneTagConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicUInt32listCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class EnumActivityGroupLinkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGroupLinkType, self.data.value) return getattr(self, '_m_value', None) class ReputationEntranceCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHomeworldFurnitureDefaultSave(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spawn_pos: self.spawn_pos = Output.Vector(self._io, self, self._root) if self.has_field_spawn_rot: self.spawn_rot = Output.Vector(self._io, self, self._root) if self.has_field_parent_furniture_index: self.parent_furniture_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_spawn_pos(self): if hasattr(self, '_m_has_field_spawn_pos'): return self._m_has_field_spawn_pos self._m_has_field_spawn_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_pos', None) @property def has_field_spawn_rot(self): if hasattr(self, '_m_has_field_spawn_rot'): return self._m_has_field_spawn_rot self._m_has_field_spawn_rot = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_spawn_rot', None) @property def has_field_parent_furniture_index(self): if hasattr(self, '_m_has_field_parent_furniture_index'): return self._m_has_field_parent_furniture_index self._m_has_field_parent_furniture_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_parent_furniture_index', None) class ChannellerSlabChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByHostOrGuest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_host: self.is_host = self._io.read_u1() @property def has_field_is_host(self): if hasattr(self, '_m_has_field_is_host'): return self._m_has_field_is_host self._m_has_field_is_host = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_host', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnableGadgetIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAudioAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_switch_key: self.voice_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_body_type_switch_key: self.body_type_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_weapon_put_away_anim_state_whitelist: self.weapon_put_away_anim_state_whitelist = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_energy_ratio_rtpc: self.energy_ratio_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_team_hp_rtpc: self.team_hp_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_team_hp_alive_ratio: self.team_hp_alive_ratio = self._io.read_f4le() if self.has_field_avatar_access_type_switch_group: self.avatar_access_type_switch_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_local_avatar_switch_value: self.local_avatar_switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_remote_avatar_switch_value: self.remote_avatar_switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_motion_avatar_type_rtpc_key: self.motion_avatar_type_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_remote_avatar_switch_value(self): if hasattr(self, '_m_has_field_remote_avatar_switch_value'): return self._m_has_field_remote_avatar_switch_value self._m_has_field_remote_avatar_switch_value = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_remote_avatar_switch_value', None) @property def has_field_body_type_switch_key(self): if hasattr(self, '_m_has_field_body_type_switch_key'): return self._m_has_field_body_type_switch_key self._m_has_field_body_type_switch_key = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_body_type_switch_key', None) @property def has_field_voice_switch_key(self): if hasattr(self, '_m_has_field_voice_switch_key'): return self._m_has_field_voice_switch_key self._m_has_field_voice_switch_key = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_voice_switch_key', None) @property def has_field_energy_ratio_rtpc(self): if hasattr(self, '_m_has_field_energy_ratio_rtpc'): return self._m_has_field_energy_ratio_rtpc self._m_has_field_energy_ratio_rtpc = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_energy_ratio_rtpc', None) @property def has_field_weapon_put_away_anim_state_whitelist(self): if hasattr(self, '_m_has_field_weapon_put_away_anim_state_whitelist'): return self._m_has_field_weapon_put_away_anim_state_whitelist self._m_has_field_weapon_put_away_anim_state_whitelist = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_weapon_put_away_anim_state_whitelist', None) @property def has_field_motion_avatar_type_rtpc_key(self): if hasattr(self, '_m_has_field_motion_avatar_type_rtpc_key'): return self._m_has_field_motion_avatar_type_rtpc_key self._m_has_field_motion_avatar_type_rtpc_key = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_motion_avatar_type_rtpc_key', None) @property def has_field_team_hp_rtpc(self): if hasattr(self, '_m_has_field_team_hp_rtpc'): return self._m_has_field_team_hp_rtpc self._m_has_field_team_hp_rtpc = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_team_hp_rtpc', None) @property def has_field_avatar_access_type_switch_group(self): if hasattr(self, '_m_has_field_avatar_access_type_switch_group'): return self._m_has_field_avatar_access_type_switch_group self._m_has_field_avatar_access_type_switch_group = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_avatar_access_type_switch_group', None) @property def has_field_local_avatar_switch_value(self): if hasattr(self, '_m_has_field_local_avatar_switch_value'): return self._m_has_field_local_avatar_switch_value self._m_has_field_local_avatar_switch_value = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_local_avatar_switch_value', None) @property def has_field_team_hp_alive_ratio(self): if hasattr(self, '_m_has_field_team_hp_alive_ratio'): return self._m_has_field_team_hp_alive_ratio self._m_has_field_team_hp_alive_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_team_hp_alive_ratio', None) class TextMapLevelStruct(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_file_num: self.min_file_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_max_file_num: self.max_file_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_auto_change_step: self.auto_change_step = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_min_file_num(self): if hasattr(self, '_m_has_field_min_file_num'): return self._m_has_field_min_file_num self._m_has_field_min_file_num = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_file_num', None) @property def has_field_max_file_num(self): if hasattr(self, '_m_has_field_max_file_num'): return self._m_has_field_max_file_num self._m_has_field_max_file_num = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_file_num', None) @property def has_field_auto_change_step(self): if hasattr(self, '_m_has_field_auto_change_step'): return self._m_has_field_auto_change_step self._m_has_field_auto_change_step = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_auto_change_step', None) class EnumOutputControlType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OutputControlType, self.data.value) return getattr(self, '_m_value', None) class PerfOptionOverrideRuleComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriPoetryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_cond_id: self.theme_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entity_type: self.entity_type = Output.EnumIrodoriPoetryEntityType(self._io, self, self._root) if self.has_field_scan_config_list: self.scan_config_list = Output.ArrayOfIrodoriPoetryScanConfigLengthS(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_inspiration_quest_id: self.min_inspiration_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fill_poetry_quest_id: self.fill_poetry_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_id_list: self.reminder_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_hint: self.camera_hint = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_title: self.theme_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_theme_desc: self.theme_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_poetry_title: self.poetry_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exists_line_id_list: self.exists_line_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_entity_type', None) @property def has_field_camera_hint(self): if hasattr(self, '_m_has_field_camera_hint'): return self._m_has_field_camera_hint self._m_has_field_camera_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_camera_hint', None) @property def has_field_fill_poetry_quest_id(self): if hasattr(self, '_m_has_field_fill_poetry_quest_id'): return self._m_has_field_fill_poetry_quest_id self._m_has_field_fill_poetry_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_fill_poetry_quest_id', None) @property def has_field_poetry_title(self): if hasattr(self, '_m_has_field_poetry_title'): return self._m_has_field_poetry_title self._m_has_field_poetry_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_poetry_title', None) @property def has_field_theme_desc(self): if hasattr(self, '_m_has_field_theme_desc'): return self._m_has_field_theme_desc self._m_has_field_theme_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_theme_desc', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_theme_cond_id(self): if hasattr(self, '_m_has_field_theme_cond_id'): return self._m_has_field_theme_cond_id self._m_has_field_theme_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_theme_cond_id', None) @property def has_field_min_inspiration_quest_id(self): if hasattr(self, '_m_has_field_min_inspiration_quest_id'): return self._m_has_field_min_inspiration_quest_id self._m_has_field_min_inspiration_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_min_inspiration_quest_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_exists_line_id_list(self): if hasattr(self, '_m_has_field_exists_line_id_list'): return self._m_has_field_exists_line_id_list self._m_has_field_exists_line_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_exists_line_id_list', None) @property def has_field_reminder_id_list(self): if hasattr(self, '_m_has_field_reminder_id_list'): return self._m_has_field_reminder_id_list self._m_has_field_reminder_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reminder_id_list', None) @property def has_field_theme_title(self): if hasattr(self, '_m_has_field_theme_title'): return self._m_has_field_theme_title self._m_has_field_theme_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_theme_title', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_scan_config_list(self): if hasattr(self, '_m_has_field_scan_config_list'): return self._m_has_field_scan_config_list self._m_has_field_scan_config_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_scan_config_list', None) class InvestigationConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioEventOnEffectOp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioOperation(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def operation(self): if hasattr(self, '_m_operation'): return self._m_operation self._m_operation = self.base.operation return getattr(self, '_m_operation', None) class DungeonLevelEntityConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_client_id: self.client_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show: self.show = self._io.read_u1() if self.has_field_level_config_name: self.level_config_name = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_switch_title: self.switch_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_client_id(self): if hasattr(self, '_m_has_field_client_id'): return self._m_has_field_client_id self._m_has_field_client_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_client_id', None) @property def has_field_level_config_name(self): if hasattr(self, '_m_has_field_level_config_name'): return self._m_has_field_level_config_name self._m_has_field_level_config_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_config_name', None) @property def has_field_switch_title(self): if hasattr(self, '_m_has_field_switch_title'): return self._m_has_field_switch_title self._m_has_field_switch_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_switch_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_show', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) class ByHasAbilityState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_state: self.ability_state = Output.EnumAbilityState(self._io, self, self._root) @property def has_field_ability_state(self): if hasattr(self, '_m_has_field_ability_state'): return self._m_has_field_ability_state self._m_has_field_ability_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_state', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ProductConcertPackageDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicGame(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_button_sequence: self.button_sequence = Output.ArrayOfConfigMusicGameKeyLengthU(self._io, self, self._root) if self.has_field_instrument: self.instrument = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_play_music_event: self.play_music_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_stop_music_event: self.stop_music_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_pause_music_event: self.pause_music_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_resume_music_event: self.resume_music_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_auto_play: self.auto_play = self._io.read_u1() @property def has_field_stop_music_event(self): if hasattr(self, '_m_has_field_stop_music_event'): return self._m_has_field_stop_music_event self._m_has_field_stop_music_event = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_stop_music_event', None) @property def has_field_button_sequence(self): if hasattr(self, '_m_has_field_button_sequence'): return self._m_has_field_button_sequence self._m_has_field_button_sequence = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_button_sequence', None) @property def has_field_pause_music_event(self): if hasattr(self, '_m_has_field_pause_music_event'): return self._m_has_field_pause_music_event self._m_has_field_pause_music_event = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_pause_music_event', None) @property def has_field_resume_music_event(self): if hasattr(self, '_m_has_field_resume_music_event'): return self._m_has_field_resume_music_event self._m_has_field_resume_music_event = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_resume_music_event', None) @property def has_field_auto_play(self): if hasattr(self, '_m_has_field_auto_play'): return self._m_has_field_auto_play self._m_has_field_auto_play = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_auto_play', None) @property def has_field_instrument(self): if hasattr(self, '_m_has_field_instrument'): return self._m_has_field_instrument self._m_has_field_instrument = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_instrument', None) @property def has_field_play_music_event(self): if hasattr(self, '_m_has_field_play_music_event'): return self._m_has_field_play_music_event self._m_has_field_play_music_event = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_play_music_event', None) class OpActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_op_activity_id: self.op_activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_type: self.bonus_type = Output.EnumOpActivityBonusType(self._io, self, self._root) if self.has_field_bonus_value: self.bonus_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_list: self.bonus_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab_text: self.tab_text = AuxTypes.String(self._io, self, self._root) if self.has_field_text_map_id_list: self.text_map_id_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_bonus_type(self): if hasattr(self, '_m_has_field_bonus_type'): return self._m_has_field_bonus_type self._m_has_field_bonus_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_bonus_type', None) @property def has_field_text_map_id_list(self): if hasattr(self, '_m_has_field_text_map_id_list'): return self._m_has_field_text_map_id_list self._m_has_field_text_map_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_text_map_id_list', None) @property def has_field_bonus_list(self): if hasattr(self, '_m_has_field_bonus_list'): return self._m_has_field_bonus_list self._m_has_field_bonus_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_bonus_list', None) @property def has_field_bonus_value(self): if hasattr(self, '_m_has_field_bonus_value'): return self._m_has_field_bonus_value self._m_has_field_bonus_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_bonus_value', None) @property def has_field_tab_text(self): if hasattr(self, '_m_has_field_tab_text'): return self._m_has_field_tab_text self._m_has_field_tab_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tab_text', None) @property def has_field_op_activity_id(self): if hasattr(self, '_m_has_field_op_activity_id'): return self._m_has_field_op_activity_id self._m_has_field_op_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_op_activity_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) class DictOfEnumInputEventTypeConfigBaseInputEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumInputEventTypeConfigBaseInputEvent(self._io, self, self._root)) class ConfigMusicInt32greaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigAudioEmitter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_emitter_lifetime: self.emitter_lifetime = self._io.read_f4le() if self.has_field_emit_interval: self.emit_interval = self._io.read_f4le() if self.has_field_inst_lifetime: self.inst_lifetime = self._io.read_f4le() if self.has_field_ending_duration: self.ending_duration = self._io.read_f4le() if self.has_field_emit_event_name: self.emit_event_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_end_event_name: self.end_event_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_multi_position_type: self.multi_position_type = Output.EnumAudioEmitterMultiPositionType(self._io, self, self._root) @property def has_field_end_event_name(self): if hasattr(self, '_m_has_field_end_event_name'): return self._m_has_field_end_event_name self._m_has_field_end_event_name = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_end_event_name', None) @property def has_field_ending_duration(self): if hasattr(self, '_m_has_field_ending_duration'): return self._m_has_field_ending_duration self._m_has_field_ending_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ending_duration', None) @property def has_field_inst_lifetime(self): if hasattr(self, '_m_has_field_inst_lifetime'): return self._m_has_field_inst_lifetime self._m_has_field_inst_lifetime = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_inst_lifetime', None) @property def has_field_multi_position_type(self): if hasattr(self, '_m_has_field_multi_position_type'): return self._m_has_field_multi_position_type self._m_has_field_multi_position_type = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_multi_position_type', None) @property def has_field_emitter_lifetime(self): if hasattr(self, '_m_has_field_emitter_lifetime'): return self._m_has_field_emitter_lifetime self._m_has_field_emitter_lifetime = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_emitter_lifetime', None) @property def has_field_emit_event_name(self): if hasattr(self, '_m_has_field_emit_event_name'): return self._m_has_field_emit_event_name self._m_has_field_emit_event_name = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_emit_event_name', None) @property def has_field_emit_interval(self): if hasattr(self, '_m_has_field_emit_interval'): return self._m_has_field_emit_interval self._m_has_field_emit_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_emit_interval', None) class ConfigMusicUInt32lessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ByFindBlinkPointSuccess(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_find_point_success: self.find_point_success = self._io.read_u1() @property def has_field_find_point_success(self): if hasattr(self, '_m_has_field_find_point_success'): return self._m_has_field_find_point_success self._m_has_field_find_point_success = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_find_point_success', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ShowTextMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumCodexQuestTextType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CodexQuestTextType, self.data.value) return getattr(self, '_m_value', None) class EnumTargetIndicatorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TargetIndicatorType, self.data.value) return getattr(self, '_m_value', None) class IrodoriFlowerThemeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CameraBlurMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_radial_blur: self.camera_radial_blur = Output.ConfigCameraRadialBlur(self._io, self, self._root) @property def has_field_camera_radial_blur(self): if hasattr(self, '_m_has_field_camera_radial_blur'): return self._m_has_field_camera_radial_blur self._m_has_field_camera_radial_blur = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_radial_blur', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumRoguelikeEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoguelikeEffectType, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetTurnState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_angle_around_x: self.angle_around_x = self._io.read_f4le() if self.has_field_angle_around_y: self.angle_around_y = self._io.read_f4le() if self.has_field_angle_around_z: self.angle_around_z = self._io.read_f4le() if self.has_field_lerp_curve_index: self.lerp_curve_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lerp_time: self.lerp_time = self._io.read_f4le() @property def has_field_angle_around_z(self): if hasattr(self, '_m_has_field_angle_around_z'): return self._m_has_field_angle_around_z self._m_has_field_angle_around_z = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_angle_around_z', None) @property def has_field_lerp_curve_index(self): if hasattr(self, '_m_has_field_lerp_curve_index'): return self._m_has_field_lerp_curve_index self._m_has_field_lerp_curve_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_lerp_curve_index', None) @property def has_field_angle_around_y(self): if hasattr(self, '_m_has_field_angle_around_y'): return self._m_has_field_angle_around_y self._m_has_field_angle_around_y = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_angle_around_y', None) @property def has_field_angle_around_x(self): if hasattr(self, '_m_has_field_angle_around_x'): return self._m_has_field_angle_around_x self._m_has_field_angle_around_x = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angle_around_x', None) @property def has_field_lerp_time(self): if hasattr(self, '_m_has_field_lerp_time'): return self._m_has_field_lerp_time self._m_has_field_lerp_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_lerp_time', None) class StringIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GalleryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSkipUnindexedEffectCreationByDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class CoopTempValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_coop_var: self.is_coop_var = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_coop_var(self): if hasattr(self, '_m_has_field_is_coop_var'): return self._m_has_field_is_coop_var self._m_has_field_is_coop_var = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_coop_var', None) class MechanicusGearLevelUpExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_id: self.gear_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_level: self.gear_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_level_up_money: self.gear_level_up_money = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_name: self.gear_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_short_name: self.gear_short_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_icon_path: self.gear_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_attack: self.attack = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attack_speed: self.attack_speed = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attack_range: self.attack_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_build_cost: self.build_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_demolition_refund: self.demolition_refund = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_value_param: self.global_value_param = Output.ArrayOfSgvConfigLengthS(self._io, self, self._root) if self.has_field_effect_list: self.effect_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_effect_list(self): if hasattr(self, '_m_has_field_effect_list'): return self._m_has_field_effect_list self._m_has_field_effect_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_effect_list', None) @property def has_field_global_value_param(self): if hasattr(self, '_m_has_field_global_value_param'): return self._m_has_field_global_value_param self._m_has_field_global_value_param = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_global_value_param', None) @property def has_field_attack_speed(self): if hasattr(self, '_m_has_field_attack_speed'): return self._m_has_field_attack_speed self._m_has_field_attack_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_attack_speed', None) @property def has_field_attack(self): if hasattr(self, '_m_has_field_attack'): return self._m_has_field_attack self._m_has_field_attack = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_attack', None) @property def has_field_demolition_refund(self): if hasattr(self, '_m_has_field_demolition_refund'): return self._m_has_field_demolition_refund self._m_has_field_demolition_refund = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_demolition_refund', None) @property def has_field_build_cost(self): if hasattr(self, '_m_has_field_build_cost'): return self._m_has_field_build_cost self._m_has_field_build_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_build_cost', None) @property def has_field_gear_level(self): if hasattr(self, '_m_has_field_gear_level'): return self._m_has_field_gear_level self._m_has_field_gear_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gear_level', None) @property def has_field_attack_range(self): if hasattr(self, '_m_has_field_attack_range'): return self._m_has_field_attack_range self._m_has_field_attack_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_attack_range', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gear_name(self): if hasattr(self, '_m_has_field_gear_name'): return self._m_has_field_gear_name self._m_has_field_gear_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gear_name', None) @property def has_field_gear_short_name(self): if hasattr(self, '_m_has_field_gear_short_name'): return self._m_has_field_gear_short_name self._m_has_field_gear_short_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_gear_short_name', None) @property def has_field_gear_icon_path(self): if hasattr(self, '_m_has_field_gear_icon_path'): return self._m_has_field_gear_icon_path self._m_has_field_gear_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_gear_icon_path', None) @property def has_field_gear_level_up_money(self): if hasattr(self, '_m_has_field_gear_level_up_money'): return self._m_has_field_gear_level_up_money self._m_has_field_gear_level_up_money = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gear_level_up_money', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_gear_id(self): if hasattr(self, '_m_has_field_gear_id'): return self._m_has_field_gear_id self._m_has_field_gear_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gear_id', None) class EnumFadeTintQualityLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FadeTintQualityLevel, self.data.value) return getattr(self, '_m_value', None) class RoguelikeCurseExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByEnergyRatio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ratio: self.ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_ratio(self): if hasattr(self, '_m_has_field_ratio'): return self._m_has_field_ratio self._m_has_field_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ratio', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActivityArenaChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_arena_challenge_id: self.arena_challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_arena_challenge_level: self.arena_challenge_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_extra_level: self.is_extra_level = self._io.read_u1() if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_target: self.challenge_target = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_target1: self.challenge_target1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_target2: self.challenge_target2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_desc: self.challenge_desc = AuxTypes.String(self._io, self, self._root) if self.has_field_challenge_desc1: self.challenge_desc1 = AuxTypes.String(self._io, self, self._root) if self.has_field_challenge_desc2: self.challenge_desc2 = AuxTypes.String(self._io, self, self._root) @property def has_field_arena_challenge_id(self): if hasattr(self, '_m_has_field_arena_challenge_id'): return self._m_has_field_arena_challenge_id self._m_has_field_arena_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_arena_challenge_id', None) @property def has_field_challenge_target(self): if hasattr(self, '_m_has_field_challenge_target'): return self._m_has_field_challenge_target self._m_has_field_challenge_target = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_challenge_target', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_challenge_desc(self): if hasattr(self, '_m_has_field_challenge_desc'): return self._m_has_field_challenge_desc self._m_has_field_challenge_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_challenge_desc', None) @property def has_field_challenge_desc2(self): if hasattr(self, '_m_has_field_challenge_desc2'): return self._m_has_field_challenge_desc2 self._m_has_field_challenge_desc2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_challenge_desc2', None) @property def has_field_is_extra_level(self): if hasattr(self, '_m_has_field_is_extra_level'): return self._m_has_field_is_extra_level self._m_has_field_is_extra_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_extra_level', None) @property def has_field_challenge_desc1(self): if hasattr(self, '_m_has_field_challenge_desc1'): return self._m_has_field_challenge_desc1 self._m_has_field_challenge_desc1 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_challenge_desc1', None) @property def has_field_challenge_target2(self): if hasattr(self, '_m_has_field_challenge_target2'): return self._m_has_field_challenge_target2 self._m_has_field_challenge_target2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_challenge_target2', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_arena_challenge_level(self): if hasattr(self, '_m_has_field_arena_challenge_level'): return self._m_has_field_arena_challenge_level self._m_has_field_arena_challenge_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_arena_challenge_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_challenge_target1(self): if hasattr(self, '_m_has_field_challenge_target1'): return self._m_has_field_challenge_target1 self._m_has_field_challenge_target1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_challenge_target1', None) class ConfigAiPrecombatSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bio_clock_sleep_from: self.bio_clock_sleep_from = self._io.read_f4le() if self.has_field_bio_clock_sleep_to: self.bio_clock_sleep_to = self._io.read_f4le() if self.has_field_satiety_time: self.satiety_time = self._io.read_f4le() if self.has_field_override_weather_neuron_mapping: self.override_weather_neuron_mapping = Output.DictOfEnumConfigWeatherTypeArrayOfEnumNeuronNameLengthU(self._io, self, self._root) @property def has_field_bio_clock_sleep_from(self): if hasattr(self, '_m_has_field_bio_clock_sleep_from'): return self._m_has_field_bio_clock_sleep_from self._m_has_field_bio_clock_sleep_from = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bio_clock_sleep_from', None) @property def has_field_bio_clock_sleep_to(self): if hasattr(self, '_m_has_field_bio_clock_sleep_to'): return self._m_has_field_bio_clock_sleep_to self._m_has_field_bio_clock_sleep_to = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bio_clock_sleep_to', None) @property def has_field_satiety_time(self): if hasattr(self, '_m_has_field_satiety_time'): return self._m_has_field_satiety_time self._m_has_field_satiety_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_satiety_time', None) @property def has_field_override_weather_neuron_mapping(self): if hasattr(self, '_m_has_field_override_weather_neuron_mapping'): return self._m_has_field_override_weather_neuron_mapping self._m_has_field_override_weather_neuron_mapping = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_override_weather_neuron_mapping', None) class ActivityCrystalLinkDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_difficulty_id: self.difficulty_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_level: self.dungeon_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_ratio: self.score_ratio = self._io.read_f4le() if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumCrystalLinkDifficultyType(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_dungeon_level(self): if hasattr(self, '_m_has_field_dungeon_level'): return self._m_has_field_dungeon_level self._m_has_field_dungeon_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_level', None) @property def has_field_score_ratio(self): if hasattr(self, '_m_has_field_score_ratio'): return self._m_has_field_score_ratio self._m_has_field_score_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score_ratio', None) @property def has_field_difficulty_id(self): if hasattr(self, '_m_has_field_difficulty_id'): return self._m_has_field_difficulty_id self._m_has_field_difficulty_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_difficulty_id', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_difficulty', None) class ConfigWidgetWaterSprite(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_trigger_name: self.ability_trigger_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_trigger_name_second: self.ability_trigger_name_second = AuxTypes.String(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def has_field_ability_trigger_name(self): if hasattr(self, '_m_has_field_ability_trigger_name'): return self._m_has_field_ability_trigger_name self._m_has_field_ability_trigger_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ability_trigger_name', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) @property def has_field_ability_trigger_name_second(self): if hasattr(self, '_m_has_field_ability_trigger_name_second'): return self._m_has_field_ability_trigger_name_second self._m_has_field_ability_trigger_name_second = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_trigger_name_second', None) class AbilityTargettingComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BartenderOrderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_formula_id: self.formula_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_affix_id: self.affix_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cup_type: self.cup_type = Output.EnumBartenderCupType(self._io, self, self._root) if self.has_field_time: self.time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_formula_id(self): if hasattr(self, '_m_has_field_formula_id'): return self._m_has_field_formula_id self._m_has_field_formula_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_formula_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_affix_id(self): if hasattr(self, '_m_has_field_affix_id'): return self._m_has_field_affix_id self._m_has_field_affix_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_affix_id', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_score', None) @property def has_field_cup_type(self): if hasattr(self, '_m_has_field_cup_type'): return self._m_has_field_cup_type self._m_has_field_cup_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cup_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_time', None) class EnumStoryCameraPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StoryCameraPosType, self.data.value) return getattr(self, '_m_value', None) class QteActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiFishingPretendBitesData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingPretendBitesData(self._io, self, self._root)) class TriggerUgcGadgetMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigLogSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_send_engine_log_to_server: self.send_engine_log_to_server = self._io.read_u1() @property def has_field_send_engine_log_to_server(self): if hasattr(self, '_m_has_field_send_engine_log_to_server'): return self._m_has_field_send_engine_log_to_server self._m_has_field_send_engine_log_to_server = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_send_engine_log_to_server', None) class CaptureTagConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_capture_type: self.capture_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_capture_type(self): if hasattr(self, '_m_has_field_capture_type'): return self._m_has_field_capture_type self._m_has_field_capture_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_capture_type', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_id', None) class EnumCrowdSpawnConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CrowdSpawnConditionType, self.data.value) return getattr(self, '_m_value', None) class ConfigExternalVoiceItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guid: self.guid = AuxTypes.String(self._io, self, self._root) if self.has_field_play_rate: self.play_rate = self._io.read_f4le() if self.has_field_initial_delay: self.initial_delay = self._io.read_f4le() if self.has_field_cooldown: self.cooldown = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_interrupted_guids: self.interrupted_guids = Output.ArrayOfConfigExternalVoiceInferiorItemLengthU(self._io, self, self._root) if self.has_field_excluded_guids: self.excluded_guids = Output.ArrayOfConfigExternalVoiceInferiorItemLengthU(self._io, self, self._root) if self.has_field_queue_up_config: self.queue_up_config = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_game_trigger: self.game_trigger = AuxTypes.String(self._io, self, self._root) if self.has_field_game_trigger_args: self.game_trigger_args = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_personal_config: self.personal_config = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_view_config: self.view_config = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_clear_all: self.clear_all = self._io.read_u1() if self.has_field_is_global_stop: self.is_global_stop = self._io.read_u1() if self.has_field_is_play_on_team: self.is_play_on_team = self._io.read_u1() if self.has_field_avoid_repeat: self.avoid_repeat = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_parent_id: self.parent_id = AuxTypes.String(self._io, self, self._root) if self.has_field_source_names: self.source_names = Output.ArrayOfConfigExternalVoiceSoundLengthU(self._io, self, self._root) @property def has_field_cooldown(self): if hasattr(self, '_m_has_field_cooldown'): return self._m_has_field_cooldown self._m_has_field_cooldown = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_cooldown', None) @property def has_field_is_play_on_team(self): if hasattr(self, '_m_has_field_is_play_on_team'): return self._m_has_field_is_play_on_team self._m_has_field_is_play_on_team = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_is_play_on_team', None) @property def has_field_avoid_repeat(self): if hasattr(self, '_m_has_field_avoid_repeat'): return self._m_has_field_avoid_repeat self._m_has_field_avoid_repeat = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_avoid_repeat', None) @property def has_field_game_trigger_args(self): if hasattr(self, '_m_has_field_game_trigger_args'): return self._m_has_field_game_trigger_args self._m_has_field_game_trigger_args = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_game_trigger_args', None) @property def has_field_clear_all(self): if hasattr(self, '_m_has_field_clear_all'): return self._m_has_field_clear_all self._m_has_field_clear_all = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_clear_all', None) @property def has_field_excluded_guids(self): if hasattr(self, '_m_has_field_excluded_guids'): return self._m_has_field_excluded_guids self._m_has_field_excluded_guids = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_excluded_guids', None) @property def has_field_personal_config(self): if hasattr(self, '_m_has_field_personal_config'): return self._m_has_field_personal_config self._m_has_field_personal_config = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_personal_config', None) @property def has_field_parent_id(self): if hasattr(self, '_m_has_field_parent_id'): return self._m_has_field_parent_id self._m_has_field_parent_id = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_parent_id', None) @property def has_field_play_rate(self): if hasattr(self, '_m_has_field_play_rate'): return self._m_has_field_play_rate self._m_has_field_play_rate = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_play_rate', None) @property def has_field_is_global_stop(self): if hasattr(self, '_m_has_field_is_global_stop'): return self._m_has_field_is_global_stop self._m_has_field_is_global_stop = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_is_global_stop', None) @property def has_field_game_trigger(self): if hasattr(self, '_m_has_field_game_trigger'): return self._m_has_field_game_trigger self._m_has_field_game_trigger = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_game_trigger', None) @property def has_field_interrupted_guids(self): if hasattr(self, '_m_has_field_interrupted_guids'): return self._m_has_field_interrupted_guids self._m_has_field_interrupted_guids = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_interrupted_guids', None) @property def has_field_queue_up_config(self): if hasattr(self, '_m_has_field_queue_up_config'): return self._m_has_field_queue_up_config self._m_has_field_queue_up_config = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_queue_up_config', None) @property def has_field_initial_delay(self): if hasattr(self, '_m_has_field_initial_delay'): return self._m_has_field_initial_delay self._m_has_field_initial_delay = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_initial_delay', None) @property def has_field_view_config(self): if hasattr(self, '_m_has_field_view_config'): return self._m_has_field_view_config self._m_has_field_view_config = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_view_config', None) @property def has_field_guid(self): if hasattr(self, '_m_has_field_guid'): return self._m_has_field_guid self._m_has_field_guid = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_guid', None) @property def has_field_source_names(self): if hasattr(self, '_m_has_field_source_names'): return self._m_has_field_source_names self._m_has_field_source_names = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_source_names', None) class BoredActionPriorityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_action_type: self.action_type = Output.EnumBoredActionType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_action_type', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weight', None) class AudioMutualExclusionItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPlaceNameConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlaceNameConditionType, self.data.value) return getattr(self, '_m_value', None) class ElementShieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_show_damage_text: self.show_damage_text = AuxTypes.String(self._io, self, self._root) if self.has_field_shield_angle: self.shield_angle = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp_ratio: self.shield_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp: self.shield_hp = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_damage_ratio: self.damage_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_on_shield_broken: self.on_shield_broken = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_shield_success: self.on_shield_success = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_shield_failed: self.on_shield_failed = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_use_muti_player_fix_data: self.use_muti_player_fix_data = self._io.read_u1() if self.has_field_update_shield_by_max_hp: self.update_shield_by_max_hp = self._io.read_u1() @property def has_field_on_shield_broken(self): if hasattr(self, '_m_has_field_on_shield_broken'): return self._m_has_field_on_shield_broken self._m_has_field_on_shield_broken = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_shield_broken', None) @property def has_field_shield_angle(self): if hasattr(self, '_m_has_field_shield_angle'): return self._m_has_field_shield_angle self._m_has_field_shield_angle = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shield_angle', None) @property def has_field_show_damage_text(self): if hasattr(self, '_m_has_field_show_damage_text'): return self._m_has_field_show_damage_text self._m_has_field_show_damage_text = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_show_damage_text', None) @property def has_field_shield_hp_ratio(self): if hasattr(self, '_m_has_field_shield_hp_ratio'): return self._m_has_field_shield_hp_ratio self._m_has_field_shield_hp_ratio = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shield_hp_ratio', None) @property def has_field_update_shield_by_max_hp(self): if hasattr(self, '_m_has_field_update_shield_by_max_hp'): return self._m_has_field_update_shield_by_max_hp self._m_has_field_update_shield_by_max_hp = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_update_shield_by_max_hp', None) @property def has_field_on_shield_failed(self): if hasattr(self, '_m_has_field_on_shield_failed'): return self._m_has_field_on_shield_failed self._m_has_field_on_shield_failed = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_on_shield_failed', None) @property def has_field_shield_hp(self): if hasattr(self, '_m_has_field_shield_hp'): return self._m_has_field_shield_hp self._m_has_field_shield_hp = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_shield_hp', None) @property def has_field_on_shield_success(self): if hasattr(self, '_m_has_field_on_shield_success'): return self._m_has_field_on_shield_success self._m_has_field_on_shield_success = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_on_shield_success', None) @property def has_field_use_muti_player_fix_data(self): if hasattr(self, '_m_has_field_use_muti_player_fix_data'): return self._m_has_field_use_muti_player_fix_data self._m_has_field_use_muti_player_fix_data = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_use_muti_player_fix_data', None) @property def has_field_damage_ratio(self): if hasattr(self, '_m_has_field_damage_ratio'): return self._m_has_field_damage_ratio self._m_has_field_damage_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_damage_ratio', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_element_type', None) class TornadoMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_stage_zone: self.stage_zone = Output.ArrayOfConfigTornadoZoneLengthU(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_enviro_wind_strength: self.enviro_wind_strength = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_enviro_wind_radius: self.enviro_wind_radius = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_enviro_wind_strength(self): if hasattr(self, '_m_has_field_enviro_wind_strength'): return self._m_has_field_enviro_wind_strength self._m_has_field_enviro_wind_strength = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_enviro_wind_strength', None) @property def has_field_enviro_wind_radius(self): if hasattr(self, '_m_has_field_enviro_wind_radius'): return self._m_has_field_enviro_wind_radius self._m_has_field_enviro_wind_radius = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_enviro_wind_radius', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_stage_zone(self): if hasattr(self, '_m_has_field_stage_zone'): return self._m_has_field_stage_zone self._m_has_field_stage_zone = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stage_zone', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_born', None) class ActivityChessMapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityBeHitEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_override_by_frozen_state: self.override_by_frozen_state = AuxTypes.String(self._io, self, self._root) if self.has_field_override_by_petrifaction_state: self.override_by_petrifaction_state = AuxTypes.String(self._io, self, self._root) if self.has_field_override_by_rock_state: self.override_by_rock_state = AuxTypes.String(self._io, self, self._root) if self.has_field_override_by_rock_resist_state: self.override_by_rock_resist_state = AuxTypes.String(self._io, self, self._root) @property def has_field_override_by_frozen_state(self): if hasattr(self, '_m_has_field_override_by_frozen_state'): return self._m_has_field_override_by_frozen_state self._m_has_field_override_by_frozen_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_by_frozen_state', None) @property def has_field_override_by_petrifaction_state(self): if hasattr(self, '_m_has_field_override_by_petrifaction_state'): return self._m_has_field_override_by_petrifaction_state self._m_has_field_override_by_petrifaction_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_override_by_petrifaction_state', None) @property def has_field_override_by_rock_state(self): if hasattr(self, '_m_has_field_override_by_rock_state'): return self._m_has_field_override_by_rock_state self._m_has_field_override_by_rock_state = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_by_rock_state', None) @property def has_field_override_by_rock_resist_state(self): if hasattr(self, '_m_has_field_override_by_rock_resist_state'): return self._m_has_field_override_by_rock_resist_state self._m_has_field_override_by_rock_resist_state = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_override_by_rock_resist_state', None) class FacingMoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTdPlayTowerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TdPlayTowerType, self.data.value) return getattr(self, '_m_value', None) class DungeonRosterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_time_str: self.open_time_str = AuxTypes.String(self._io, self, self._root) if self.has_field_cycle_time: self.cycle_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cycle_type: self.cycle_type = Output.EnumDungeonRosterCycleType(self._io, self, self._root) if self.has_field_roster_pool: self.roster_pool = Output.ArrayOfDungeonListLengthS(self._io, self, self._root) @property def has_field_cycle_time(self): if hasattr(self, '_m_has_field_cycle_time'): return self._m_has_field_cycle_time self._m_has_field_cycle_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cycle_time', None) @property def has_field_roster_pool(self): if hasattr(self, '_m_has_field_roster_pool'): return self._m_has_field_roster_pool self._m_has_field_roster_pool = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_roster_pool', None) @property def has_field_cycle_type(self): if hasattr(self, '_m_has_field_cycle_type'): return self._m_has_field_cycle_type self._m_has_field_cycle_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cycle_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_time_str(self): if hasattr(self, '_m_has_field_open_time_str'): return self._m_has_field_open_time_str self._m_has_field_open_time_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_time_str', None) class RogueGadgetDirTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2projectionSwitchButtonConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumAddActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AddActionType, self.data.value) return getattr(self, '_m_value', None) class EnumFrameFaceAnimationPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FrameFaceAnimationPlayType, self.data.value) return getattr(self, '_m_value', None) class BounceConjuringItemExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWeatherTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDragonSpineMissionFinishExecType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DragonSpineMissionFinishExecType, self.data.value) return getattr(self, '_m_value', None) class EnumQuestContentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestContentType, self.data.value) return getattr(self, '_m_value', None) class ByHasShieldBar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_use_potent_shield: self.use_potent_shield = self._io.read_u1() if self.has_field_potent_shield_type: self.potent_shield_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_use_potent_shield(self): if hasattr(self, '_m_has_field_use_potent_shield'): return self._m_has_field_use_potent_shield self._m_has_field_use_potent_shield = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_potent_shield', None) @property def has_field_potent_shield_type(self): if hasattr(self, '_m_has_field_potent_shield_type'): return self._m_has_field_potent_shield_type self._m_has_field_potent_shield_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_potent_shield_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfAudioRequirementLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioRequirement(self._io, self, self._root)) class ItemUseConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_use_op: self.use_op = Output.EnumItemUseOp(self._io, self, self._root) if self.has_field_use_param: self.use_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_use_op(self): if hasattr(self, '_m_has_field_use_op'): return self._m_has_field_use_op self._m_has_field_use_op = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_use_op', None) @property def has_field_use_param(self): if hasattr(self, '_m_has_field_use_param'): return self._m_has_field_use_param self._m_has_field_use_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_use_param', None) class DictOfEnumInputEventTypeArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumInputEventTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root)) class KvpOfDictAuxTypesStringAudioWeatherProperties(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.AudioWeatherProperties(self._io, self, self._root) class OutputControlTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBaseEquipController(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseEquipController(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigEquipController(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigSubEquipController(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class KvpOfDictAuxTypesVlqBase128LeSArrayOfEquipSizeDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ArrayOfEquipSizeDataLengthU(self._io, self, self._root) class InterTimingTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MechanicusWatcherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeRadarExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TileSpecialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IconAdsorbEffectExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_effect_id: self.effect_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_id_list: self.icon_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_effect_id(self): if hasattr(self, '_m_has_field_effect_id'): return self._m_has_field_effect_id self._m_has_field_effect_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_effect_id', None) @property def has_field_icon_id_list(self): if hasattr(self, '_m_has_field_icon_id_list'): return self._m_has_field_icon_id_list self._m_has_field_icon_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon_id_list', None) class ClampDamageReceivedMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_clamp_type: self.clamp_type = Output.EnumDamageClampType(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_clamp_type(self): if hasattr(self, '_m_has_field_clamp_type'): return self._m_has_field_clamp_type self._m_has_field_clamp_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_clamp_type', None) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_value', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigPlayerNpcEnergyTypeAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_hero_engergy_type: self.set_hero_engergy_type = self._io.read_u1() @property def has_field_set_hero_engergy_type(self): if hasattr(self, '_m_has_field_set_hero_engergy_type'): return self._m_has_field_set_hero_engergy_type self._m_has_field_set_hero_engergy_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_hero_engergy_type', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class GadgetChainExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFishingEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FishingEvent, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigVCustomMapMarkLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigVCustomMapMark(self._io, self, self._root)) class ConfigTemplateData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_template_name: self.template_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param_datas: self.param_datas = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_template_name(self): if hasattr(self, '_m_has_field_template_name'): return self._m_has_field_template_name self._m_has_field_template_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_template_name', None) @property def has_field_param_datas(self): if hasattr(self, '_m_has_field_param_datas'): return self._m_has_field_param_datas self._m_has_field_param_datas = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param_datas', None) class OpenStateConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFollowAttachOccupyPriority(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FollowAttachOccupyPriority, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumPerfRatingCategoryEnumPerfRatingCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPerfRatingCategory(self._io, self, self._root) self.value = Output.EnumPerfRatingCategory(self._io, self, self._root) class EnumTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TriggerType, self.data.value) return getattr(self, '_m_value', None) class EnumConfigAiCombatPhase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigAiCombatPhase, self.data.value) return getattr(self, '_m_value', None) class EnumEchoShellType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EchoShellType, self.data.value) return getattr(self, '_m_value', None) class TowerBuff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tower_buff_id: self.tower_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tower_buff_id(self): if hasattr(self, '_m_has_field_tower_buff_id'): return self._m_has_field_tower_buff_id self._m_has_field_tower_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tower_buff_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_weight', None) class EnumCombatEndType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CombatEndType, self.data.value) return getattr(self, '_m_value', None) class EnumBoardEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BoardEventType, self.data.value) return getattr(self, '_m_value', None) class HpBarStyleComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDummyAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbility(self._io, self, self._root) @property def is_dynamic_ability(self): if hasattr(self, '_m_is_dynamic_ability'): return self._m_is_dynamic_ability self._m_is_dynamic_ability = self.base.is_dynamic_ability return getattr(self, '_m_is_dynamic_ability', None) @property def on_attach(self): if hasattr(self, '_m_on_attach'): return self._m_on_attach self._m_on_attach = self.base.on_attach return getattr(self, '_m_on_attach', None) @property def default_modifier(self): if hasattr(self, '_m_default_modifier'): return self._m_default_modifier self._m_default_modifier = self.base.default_modifier return getattr(self, '_m_default_modifier', None) @property def ability_specials(self): if hasattr(self, '_m_ability_specials'): return self._m_ability_specials self._m_ability_specials = self.base.ability_specials return getattr(self, '_m_ability_specials', None) @property def on_ability_start(self): if hasattr(self, '_m_on_ability_start'): return self._m_on_ability_start self._m_on_ability_start = self.base.on_ability_start return getattr(self, '_m_on_ability_start', None) @property def on_zone_enter(self): if hasattr(self, '_m_on_zone_enter'): return self._m_on_zone_enter self._m_on_zone_enter = self.base.on_zone_enter return getattr(self, '_m_on_zone_enter', None) @property def on_added(self): if hasattr(self, '_m_on_added'): return self._m_on_added self._m_on_added = self.base.on_added return getattr(self, '_m_on_added', None) @property def ability_defined_properties(self): if hasattr(self, '_m_ability_defined_properties'): return self._m_ability_defined_properties self._m_ability_defined_properties = self.base.ability_defined_properties return getattr(self, '_m_ability_defined_properties', None) @property def on_zone_exit(self): if hasattr(self, '_m_on_zone_exit'): return self._m_on_zone_exit self._m_on_zone_exit = self.base.on_zone_exit return getattr(self, '_m_on_zone_exit', None) @property def on_avatar_in(self): if hasattr(self, '_m_on_avatar_in'): return self._m_on_avatar_in self._m_on_avatar_in = self.base.on_avatar_in return getattr(self, '_m_on_avatar_in', None) @property def on_field_exit(self): if hasattr(self, '_m_on_field_exit'): return self._m_on_field_exit self._m_on_field_exit = self.base.on_field_exit return getattr(self, '_m_on_field_exit', None) @property def modifiers(self): if hasattr(self, '_m_modifiers'): return self._m_modifiers self._m_modifiers = self.base.modifiers return getattr(self, '_m_modifiers', None) @property def on_field_enter(self): if hasattr(self, '_m_on_field_enter'): return self._m_on_field_enter self._m_on_field_enter = self.base.on_field_enter return getattr(self, '_m_on_field_enter', None) @property def on_trigger_avatar_ray(self): if hasattr(self, '_m_on_trigger_avatar_ray'): return self._m_on_trigger_avatar_ray self._m_on_trigger_avatar_ray = self.base.on_trigger_avatar_ray return getattr(self, '_m_on_trigger_avatar_ray', None) @property def ability_name(self): if hasattr(self, '_m_ability_name'): return self._m_ability_name self._m_ability_name = self.base.ability_name return getattr(self, '_m_ability_name', None) @property def ability_mixins(self): if hasattr(self, '_m_ability_mixins'): return self._m_ability_mixins self._m_ability_mixins = self.base.ability_mixins return getattr(self, '_m_ability_mixins', None) @property def on_vehicle_out(self): if hasattr(self, '_m_on_vehicle_out'): return self._m_on_vehicle_out self._m_on_vehicle_out = self.base.on_vehicle_out return getattr(self, '_m_on_vehicle_out', None) @property def on_kill(self): if hasattr(self, '_m_on_kill'): return self._m_on_kill self._m_on_kill = self.base.on_kill return getattr(self, '_m_on_kill', None) @property def on_removed(self): if hasattr(self, '_m_on_removed'): return self._m_on_removed self._m_on_removed = self.base.on_removed return getattr(self, '_m_on_removed', None) @property def on_vehicle_in(self): if hasattr(self, '_m_on_vehicle_in'): return self._m_on_vehicle_in self._m_on_vehicle_in = self.base.on_vehicle_in return getattr(self, '_m_on_vehicle_in', None) @property def on_avatar_out(self): if hasattr(self, '_m_on_avatar_out'): return self._m_on_avatar_out self._m_on_avatar_out = self.base.on_avatar_out return getattr(self, '_m_on_avatar_out', None) @property def on_detach(self): if hasattr(self, '_m_on_detach'): return self._m_on_detach self._m_on_detach = self.base.on_detach return getattr(self, '_m_on_detach', None) class BirthdayMailExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mail_id: self.mail_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effective_date: self.effective_date = AuxTypes.String(self._io, self, self._root) if self.has_field_effective_timestamp: self.effective_timestamp = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_mail_id(self): if hasattr(self, '_m_has_field_mail_id'): return self._m_has_field_mail_id self._m_has_field_mail_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mail_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_effective_timestamp(self): if hasattr(self, '_m_has_field_effective_timestamp'): return self._m_has_field_effective_timestamp self._m_has_field_effective_timestamp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effective_timestamp', None) @property def has_field_effective_date(self): if hasattr(self, '_m_has_field_effective_date'): return self._m_has_field_effective_date self._m_has_field_effective_date = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effective_date', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ArrayOfDispConfigQteStepBaseActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigQteStepBaseAction(self._io, self, self._root)) class ReputationEntranceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByAvatarBodyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_body_type: self.body_type = AuxTypes.String(self._io, self, self._root) @property def has_field_body_type(self): if hasattr(self, '_m_has_field_body_type'): return self._m_has_field_body_type self._m_has_field_body_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_body_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class RoguelikeCurseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_curse_name: self.curse_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_config: self.effect_config = Output.RoguelikeEffectExcelConfig(self._io, self, self._root) if self.has_field_is_dynamic_show: self.is_dynamic_show = self._io.read_u1() if self.has_field_is_clear_at_next_level: self.is_clear_at_next_level = self._io.read_u1() if self.has_field_desc_param_list: self.desc_param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_desc_param_superposition_list: self.desc_param_superposition_list = Output.ArrayOfU1LengthU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_is_dynamic_show(self): if hasattr(self, '_m_has_field_is_dynamic_show'): return self._m_has_field_is_dynamic_show self._m_has_field_is_dynamic_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_dynamic_show', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_curse_name(self): if hasattr(self, '_m_has_field_curse_name'): return self._m_has_field_curse_name self._m_has_field_curse_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_curse_name', None) @property def has_field_effect_config(self): if hasattr(self, '_m_has_field_effect_config'): return self._m_has_field_effect_config self._m_has_field_effect_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effect_config', None) @property def has_field_desc_param_superposition_list(self): if hasattr(self, '_m_has_field_desc_param_superposition_list'): return self._m_has_field_desc_param_superposition_list self._m_has_field_desc_param_superposition_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc_param_superposition_list', None) @property def has_field_desc_param_list(self): if hasattr(self, '_m_has_field_desc_param_list'): return self._m_has_field_desc_param_list self._m_has_field_desc_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc_param_list', None) @property def has_field_is_clear_at_next_level(self): if hasattr(self, '_m_has_field_is_clear_at_next_level'): return self._m_has_field_is_clear_at_next_level self._m_has_field_is_clear_at_next_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_clear_at_next_level', None) class GrowCurveInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumGrowCurveType(self._io, self, self._root) if self.has_field_arith: self.arith = Output.EnumArithType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_arith(self): if hasattr(self, '_m_has_field_arith'): return self._m_has_field_arith self._m_has_field_arith = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_arith', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_value', None) class EnumRogueCreateGadgetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueCreateGadgetType, self.data.value) return getattr(self, '_m_value', None) class ClearLockTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_only_avatar: self.only_avatar = self._io.read_u1() @property def has_field_only_avatar(self): if hasattr(self, '_m_has_field_only_avatar'): return self._m_has_field_only_avatar self._m_has_field_only_avatar = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_only_avatar', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumCombineUnlockMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CombineUnlockMethod, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigAudioIncrementalResources(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAudioIncrementalResources(self._io, self, self._root) class ConfigCustomLevelBrick(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_brick_size: self.brick_size = Output.Vector(self._io, self, self._root) if self.has_field_pile_tags: self.pile_tags = Output.ArrayOfEnumPileTagLengthU(self._io, self, self._root) if self.has_field_camera_focus_dis: self.camera_focus_dis = self._io.read_f4le() if self.has_field_is_creater: self.is_creater = self._io.read_u1() if self.has_field_creater_dir: self.creater_dir = Output.EnumCreaterDir(self._io, self, self._root) if self.has_field_born_tag: self.born_tag = Output.EnumCreaterBornTag(self._io, self, self._root) if self.has_field_server_gadget_id: self.server_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_level: self.config_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_creater(self): if hasattr(self, '_m_has_field_is_creater'): return self._m_has_field_is_creater self._m_has_field_is_creater = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_creater', None) @property def has_field_pile_tags(self): if hasattr(self, '_m_has_field_pile_tags'): return self._m_has_field_pile_tags self._m_has_field_pile_tags = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_pile_tags', None) @property def has_field_config_level(self): if hasattr(self, '_m_has_field_config_level'): return self._m_has_field_config_level self._m_has_field_config_level = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_config_level', None) @property def has_field_creater_dir(self): if hasattr(self, '_m_has_field_creater_dir'): return self._m_has_field_creater_dir self._m_has_field_creater_dir = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_creater_dir', None) @property def has_field_brick_size(self): if hasattr(self, '_m_has_field_brick_size'): return self._m_has_field_brick_size self._m_has_field_brick_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_brick_size', None) @property def has_field_born_tag(self): if hasattr(self, '_m_has_field_born_tag'): return self._m_has_field_born_tag self._m_has_field_born_tag = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_born_tag', None) @property def has_field_camera_focus_dis(self): if hasattr(self, '_m_has_field_camera_focus_dis'): return self._m_has_field_camera_focus_dis self._m_has_field_camera_focus_dis = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camera_focus_dis', None) @property def has_field_server_gadget_id(self): if hasattr(self, '_m_has_field_server_gadget_id'): return self._m_has_field_server_gadget_id self._m_has_field_server_gadget_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_server_gadget_id', None) class ConfigBulletPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetPattern(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_actions: self.trigger_actions = Output.ArrayOfDispConfigBaseGadgetTriggerActionLengthU(self._io, self, self._root) if self.has_field_trigger_life_over_actions: self.trigger_life_over_actions = Output.ArrayOfDispConfigBaseGadgetTriggerActionLengthU(self._io, self, self._root) if self.has_field_kill_by_other: self.kill_by_other = self._io.read_u1() if self.has_field_die_delay_time: self.die_delay_time = self._io.read_f4le() if self.has_field_fire_ai_sound_event: self.fire_ai_sound_event = self._io.read_u1() if self.has_field_max_auto_kill_dist: self.max_auto_kill_dist = self._io.read_f4le() if self.has_field_enable_collision_delay: self.enable_collision_delay = self._io.read_f4le() @property def collider_check_on_init(self): if hasattr(self, '_m_collider_check_on_init'): return self._m_collider_check_on_init self._m_collider_check_on_init = self.base.collider_check_on_init return getattr(self, '_m_collider_check_on_init', None) @property def has_field_kill_by_other(self): if hasattr(self, '_m_has_field_kill_by_other'): return self._m_has_field_kill_by_other self._m_has_field_kill_by_other = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_kill_by_other', None) @property def has_field_enable_collision_delay(self): if hasattr(self, '_m_has_field_enable_collision_delay'): return self._m_has_field_enable_collision_delay self._m_has_field_enable_collision_delay = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_enable_collision_delay', None) @property def collision(self): if hasattr(self, '_m_collision'): return self._m_collision self._m_collision = self.base.collision return getattr(self, '_m_collision', None) @property def has_field_trigger_life_over_actions(self): if hasattr(self, '_m_has_field_trigger_life_over_actions'): return self._m_has_field_trigger_life_over_actions self._m_has_field_trigger_life_over_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_life_over_actions', None) @property def has_field_max_auto_kill_dist(self): if hasattr(self, '_m_has_field_max_auto_kill_dist'): return self._m_has_field_max_auto_kill_dist self._m_has_field_max_auto_kill_dist = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_max_auto_kill_dist', None) @property def has_field_trigger_actions(self): if hasattr(self, '_m_has_field_trigger_actions'): return self._m_has_field_trigger_actions self._m_has_field_trigger_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_actions', None) @property def has_field_die_delay_time(self): if hasattr(self, '_m_has_field_die_delay_time'): return self._m_has_field_die_delay_time self._m_has_field_die_delay_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_die_delay_time', None) @property def has_field_fire_ai_sound_event(self): if hasattr(self, '_m_has_field_fire_ai_sound_event'): return self._m_has_field_fire_ai_sound_event self._m_has_field_fire_ai_sound_event = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_fire_ai_sound_event', None) class ArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(AuxTypes.String(self._io, self, self._root)) class DictOfEnumConfigWeatherTypeArrayOfEnumNeuronNameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumConfigWeatherTypeArrayOfEnumNeuronNameLengthU(self._io, self, self._root)) class MoonfinTrialExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id_list: self.level_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_activity_fish_id: self.activity_fish_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_fish_gain_limit: self.activity_fish_gain_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_fish_pool_id: self.activity_fish_pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_reward_preview_id: self.activity_reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_list: self.main_quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_precondition_main_quest_ids: self.precondition_main_quest_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_level_id_list(self): if hasattr(self, '_m_has_field_level_id_list'): return self._m_has_field_level_id_list self._m_has_field_level_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_id_list', None) @property def has_field_activity_fish_pool_id(self): if hasattr(self, '_m_has_field_activity_fish_pool_id'): return self._m_has_field_activity_fish_pool_id self._m_has_field_activity_fish_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_activity_fish_pool_id', None) @property def has_field_main_quest_list(self): if hasattr(self, '_m_has_field_main_quest_list'): return self._m_has_field_main_quest_list self._m_has_field_main_quest_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_main_quest_list', None) @property def has_field_precondition_main_quest_ids(self): if hasattr(self, '_m_has_field_precondition_main_quest_ids'): return self._m_has_field_precondition_main_quest_ids self._m_has_field_precondition_main_quest_ids = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_precondition_main_quest_ids', None) @property def has_field_activity_fish_id(self): if hasattr(self, '_m_has_field_activity_fish_id'): return self._m_has_field_activity_fish_id self._m_has_field_activity_fish_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_activity_fish_id', None) @property def has_field_activity_fish_gain_limit(self): if hasattr(self, '_m_has_field_activity_fish_gain_limit'): return self._m_has_field_activity_fish_gain_limit self._m_has_field_activity_fish_gain_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_fish_gain_limit', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_activity_reward_preview_id(self): if hasattr(self, '_m_has_field_activity_reward_preview_id'): return self._m_has_field_activity_reward_preview_id self._m_has_field_activity_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_activity_reward_preview_id', None) class ConfigAiSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigPreloadType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigPreloadType, self.data.value) return getattr(self, '_m_value', None) class MatchNewRuleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_sub_type: self.dungeon_sub_type = Output.EnumDungeonSubType(self._io, self, self._root) if self.has_field_is_enable: self.is_enable = self._io.read_u1() if self.has_field_min_level: self.min_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_level_boundary: self.player_level_boundary = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_boundary: self.time_boundary = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_enable(self): if hasattr(self, '_m_has_field_is_enable'): return self._m_has_field_is_enable self._m_has_field_is_enable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_enable', None) @property def has_field_time_boundary(self): if hasattr(self, '_m_has_field_time_boundary'): return self._m_has_field_time_boundary self._m_has_field_time_boundary = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_time_boundary', None) @property def has_field_min_level(self): if hasattr(self, '_m_has_field_min_level'): return self._m_has_field_min_level self._m_has_field_min_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_min_level', None) @property def has_field_player_level_boundary(self): if hasattr(self, '_m_has_field_player_level_boundary'): return self._m_has_field_player_level_boundary self._m_has_field_player_level_boundary = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_player_level_boundary', None) @property def has_field_dungeon_sub_type(self): if hasattr(self, '_m_has_field_dungeon_sub_type'): return self._m_has_field_dungeon_sub_type self._m_has_field_dungeon_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_sub_type', None) class PsActivitiesTaskConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopmallSubTabExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCoopAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_action_type: self.action_type = Output.EnumCoopActionType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class ConfigRuleCullingDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class ConfigAbilityFrameData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_frame: self.frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_data: self.data = Output.ArrayOfConfigAbilityNodeLengthU(self._io, self, self._root) @property def has_field_frame(self): if hasattr(self, '_m_has_field_frame'): return self._m_has_field_frame self._m_has_field_frame = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_frame', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_data(self): if hasattr(self, '_m_has_field_data'): return self._m_has_field_data self._m_has_field_data = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_data', None) class CustomGadgetSlotGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_slot_identifier: self.slot_identifier = AuxTypes.String(self._io, self, self._root) if self.has_field_slot_list: self.slot_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_slot_identifier(self): if hasattr(self, '_m_has_field_slot_identifier'): return self._m_has_field_slot_identifier self._m_has_field_slot_identifier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_slot_identifier', None) @property def has_field_slot_list(self): if hasattr(self, '_m_has_field_slot_list'): return self._m_has_field_slot_list self._m_has_field_slot_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_slot_list', None) class EnumRewardResourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RewardResourceType, self.data.value) return getattr(self, '_m_value', None) class ConfigAudioIncrementalResources(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sfx_files: self.sfx_files = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_music_files: self.music_files = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_vo_files: self.vo_files = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_sfx_files(self): if hasattr(self, '_m_has_field_sfx_files'): return self._m_has_field_sfx_files self._m_has_field_sfx_files = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sfx_files', None) @property def has_field_music_files(self): if hasattr(self, '_m_has_field_music_files'): return self._m_has_field_music_files self._m_has_field_music_files = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_music_files', None) @property def has_field_vo_files(self): if hasattr(self, '_m_has_field_vo_files'): return self._m_has_field_vo_files self._m_has_field_vo_files = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_vo_files', None) class DictOfAuxTypesStringConfigAnimationRecurrentSpeech(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAnimationRecurrentSpeech(self._io, self, self._root)) class ConfigPerfGradeItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_value: self.override_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_override_value(self): if hasattr(self, '_m_has_field_override_value'): return self._m_has_field_override_value self._m_has_field_override_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_value', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) class WidgetGeneralExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SendPostionToShaderCutMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_send_target: self.send_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_send_radius: self.send_radius = self._io.read_f4le() if self.has_field_scale: self.scale = Output.Vector(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) @property def has_field_send_target(self): if hasattr(self, '_m_has_field_send_target'): return self._m_has_field_send_target self._m_has_field_send_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_send_target', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_send_radius(self): if hasattr(self, '_m_has_field_send_radius'): return self._m_has_field_send_radius self._m_has_field_send_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_send_radius', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigEffectAttachSkinnedMesh(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEffectAttachShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mesh: self.mesh = AuxTypes.String(self._io, self, self._root) @property def has_field_mesh(self): if hasattr(self, '_m_has_field_mesh'): return self._m_has_field_mesh self._m_has_field_mesh = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mesh', None) class EnumChallengeCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChallengeCondType, self.data.value) return getattr(self, '_m_value', None) class BoredMonsterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigGuideProjectionGameFinishAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_guide_type: self.guide_type = Output.EnumProjectionGameGuideType(self._io, self, self._root) if self.has_field_input_mode: self.input_mode = Output.EnumProjectionGameGuideInputMode(self._io, self, self._root) @property def has_field_guide_type(self): if hasattr(self, '_m_has_field_guide_type'): return self._m_has_field_guide_type self._m_has_field_guide_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_guide_type', None) @property def has_field_input_mode(self): if hasattr(self, '_m_has_field_input_mode'): return self._m_has_field_input_mode self._m_has_field_input_mode = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_input_mode', None) class MpPlayGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_entry_id: self.entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_id: self.play_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_lua_call_group_list: self.server_lua_call_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_resin_cost: self.resin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_cost_id: self.material_cost_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_cost_num: self.material_cost_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_direct_to_bag: self.is_direct_to_bag = self._io.read_u1() if self.has_field_up_avatar_list: self.up_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_client_show_type: self.client_show_type = Output.EnumMpPlayShowType(self._io, self, self._root) if self.has_field_reward_vec: self.reward_vec = Output.ArrayOfMpCrucibleRewardConfigLengthS(self._io, self, self._root) if self.has_field_activate_group_list: self.activate_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_list: self.group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_born_group_id: self.born_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born_config_id: self.born_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_safe_group_id: self.safe_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_safe_config_id: self.safe_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reborn_group_id: self.reborn_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reborn_config_id: self.reborn_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_group_id: self.reward_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_config_id: self.reward_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_general_reward_config_id: self.general_reward_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prepare_time: self.prepare_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_prepare_time: self.single_prepare_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_pos_list: self.center_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_center_radius: self.center_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_pos_list: self.target_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_revise_id: self.revise_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rate_list: self.rate_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_limit_region: self.limit_region = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_group_list: self.ability_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_disabled: self.is_disabled = self._io.read_u1() @property def has_field_center_radius(self): if hasattr(self, '_m_has_field_center_radius'): return self._m_has_field_center_radius self._m_has_field_center_radius = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_center_radius', None) @property def has_field_safe_config_id(self): if hasattr(self, '_m_has_field_safe_config_id'): return self._m_has_field_safe_config_id self._m_has_field_safe_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_safe_config_id', None) @property def has_field_material_cost_num(self): if hasattr(self, '_m_has_field_material_cost_num'): return self._m_has_field_material_cost_num self._m_has_field_material_cost_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_material_cost_num', None) @property def has_field_revise_id(self): if hasattr(self, '_m_has_field_revise_id'): return self._m_has_field_revise_id self._m_has_field_revise_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_revise_id', None) @property def has_field_target_pos_list(self): if hasattr(self, '_m_has_field_target_pos_list'): return self._m_has_field_target_pos_list self._m_has_field_target_pos_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_target_pos_list', None) @property def has_field_rate_list(self): if hasattr(self, '_m_has_field_rate_list'): return self._m_has_field_rate_list self._m_has_field_rate_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_rate_list', None) @property def has_field_reborn_group_id(self): if hasattr(self, '_m_has_field_reborn_group_id'): return self._m_has_field_reborn_group_id self._m_has_field_reborn_group_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_reborn_group_id', None) @property def has_field_material_cost_id(self): if hasattr(self, '_m_has_field_material_cost_id'): return self._m_has_field_material_cost_id self._m_has_field_material_cost_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_material_cost_id', None) @property def has_field_is_direct_to_bag(self): if hasattr(self, '_m_has_field_is_direct_to_bag'): return self._m_has_field_is_direct_to_bag self._m_has_field_is_direct_to_bag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_direct_to_bag', None) @property def has_field_safe_group_id(self): if hasattr(self, '_m_has_field_safe_group_id'): return self._m_has_field_safe_group_id self._m_has_field_safe_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_safe_group_id', None) @property def has_field_reborn_config_id(self): if hasattr(self, '_m_has_field_reborn_config_id'): return self._m_has_field_reborn_config_id self._m_has_field_reborn_config_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_reborn_config_id', None) @property def has_field_entry_id(self): if hasattr(self, '_m_has_field_entry_id'): return self._m_has_field_entry_id self._m_has_field_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_entry_id', None) @property def has_field_group_list(self): if hasattr(self, '_m_has_field_group_list'): return self._m_has_field_group_list self._m_has_field_group_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_group_list', None) @property def has_field_limit_region(self): if hasattr(self, '_m_has_field_limit_region'): return self._m_has_field_limit_region self._m_has_field_limit_region = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_limit_region', None) @property def has_field_up_avatar_list(self): if hasattr(self, '_m_has_field_up_avatar_list'): return self._m_has_field_up_avatar_list self._m_has_field_up_avatar_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_up_avatar_list', None) @property def has_field_resin_cost(self): if hasattr(self, '_m_has_field_resin_cost'): return self._m_has_field_resin_cost self._m_has_field_resin_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_resin_cost', None) @property def has_field_client_show_type(self): if hasattr(self, '_m_has_field_client_show_type'): return self._m_has_field_client_show_type self._m_has_field_client_show_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_client_show_type', None) @property def has_field_activate_group_list(self): if hasattr(self, '_m_has_field_activate_group_list'): return self._m_has_field_activate_group_list self._m_has_field_activate_group_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_activate_group_list', None) @property def has_field_general_reward_config_id(self): if hasattr(self, '_m_has_field_general_reward_config_id'): return self._m_has_field_general_reward_config_id self._m_has_field_general_reward_config_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_general_reward_config_id', None) @property def has_field_reward_vec(self): if hasattr(self, '_m_has_field_reward_vec'): return self._m_has_field_reward_vec self._m_has_field_reward_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reward_vec', None) @property def has_field_prepare_time(self): if hasattr(self, '_m_has_field_prepare_time'): return self._m_has_field_prepare_time self._m_has_field_prepare_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_prepare_time', None) @property def has_field_server_lua_call_group_list(self): if hasattr(self, '_m_has_field_server_lua_call_group_list'): return self._m_has_field_server_lua_call_group_list self._m_has_field_server_lua_call_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_server_lua_call_group_list', None) @property def has_field_born_config_id(self): if hasattr(self, '_m_has_field_born_config_id'): return self._m_has_field_born_config_id self._m_has_field_born_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_born_config_id', None) @property def has_field_center_pos_list(self): if hasattr(self, '_m_has_field_center_pos_list'): return self._m_has_field_center_pos_list self._m_has_field_center_pos_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_center_pos_list', None) @property def has_field_single_prepare_time(self): if hasattr(self, '_m_has_field_single_prepare_time'): return self._m_has_field_single_prepare_time self._m_has_field_single_prepare_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_single_prepare_time', None) @property def has_field_reward_group_id(self): if hasattr(self, '_m_has_field_reward_group_id'): return self._m_has_field_reward_group_id self._m_has_field_reward_group_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_reward_group_id', None) @property def has_field_is_disabled(self): if hasattr(self, '_m_has_field_is_disabled'): return self._m_has_field_is_disabled self._m_has_field_is_disabled = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_is_disabled', None) @property def has_field_ability_group_list(self): if hasattr(self, '_m_has_field_ability_group_list'): return self._m_has_field_ability_group_list self._m_has_field_ability_group_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_ability_group_list', None) @property def has_field_reward_config_id(self): if hasattr(self, '_m_has_field_reward_config_id'): return self._m_has_field_reward_config_id self._m_has_field_reward_config_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_reward_config_id', None) @property def has_field_play_id(self): if hasattr(self, '_m_has_field_play_id'): return self._m_has_field_play_id self._m_has_field_play_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_play_id', None) @property def has_field_born_group_id(self): if hasattr(self, '_m_has_field_born_group_id'): return self._m_has_field_born_group_id self._m_has_field_born_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_born_group_id', None) class EnumSceneSurfaceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneSurfaceType, self.data.value) return getattr(self, '_m_value', None) class AsterAvatarUpExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DraftExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_transfer_config: self.transfer_config = Output.ArrayOfDraftTransferConfigLengthS(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exec: self.exec = Output.EnumDraftExecType(self._io, self, self._root) if self.has_field_exec_sub_type: self.exec_sub_type = Output.EnumDraftExecSubType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable_mp: self.enable_mp = self._io.read_u1() if self.has_field_is_need_all_agree: self.is_need_all_agree = self._io.read_u1() if self.has_field_confirm_count_down: self.confirm_count_down = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_player_count: self.min_player_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_need_twice_confirm: self.is_need_twice_confirm = self._io.read_u1() if self.has_field_twice_confirm_count_down: self.twice_confirm_count_down = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_exec_when_count_down_over: self.is_exec_when_count_down_over = self._io.read_u1() @property def has_field_is_need_twice_confirm(self): if hasattr(self, '_m_has_field_is_need_twice_confirm'): return self._m_has_field_is_need_twice_confirm self._m_has_field_is_need_twice_confirm = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_need_twice_confirm', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_transfer_config(self): if hasattr(self, '_m_has_field_transfer_config'): return self._m_has_field_transfer_config self._m_has_field_transfer_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_transfer_config', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_is_exec_when_count_down_over(self): if hasattr(self, '_m_has_field_is_exec_when_count_down_over'): return self._m_has_field_is_exec_when_count_down_over self._m_has_field_is_exec_when_count_down_over = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_exec_when_count_down_over', None) @property def has_field_min_player_count(self): if hasattr(self, '_m_has_field_min_player_count'): return self._m_has_field_min_player_count self._m_has_field_min_player_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_min_player_count', None) @property def has_field_exec(self): if hasattr(self, '_m_has_field_exec'): return self._m_has_field_exec self._m_has_field_exec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_exec', None) @property def has_field_enable_mp(self): if hasattr(self, '_m_has_field_enable_mp'): return self._m_has_field_enable_mp self._m_has_field_enable_mp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_enable_mp', None) @property def has_field_twice_confirm_count_down(self): if hasattr(self, '_m_has_field_twice_confirm_count_down'): return self._m_has_field_twice_confirm_count_down self._m_has_field_twice_confirm_count_down = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_twice_confirm_count_down', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_confirm_count_down(self): if hasattr(self, '_m_has_field_confirm_count_down'): return self._m_has_field_confirm_count_down self._m_has_field_confirm_count_down = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_confirm_count_down', None) @property def has_field_is_need_all_agree(self): if hasattr(self, '_m_has_field_is_need_all_agree'): return self._m_has_field_is_need_all_agree self._m_has_field_is_need_all_agree = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_need_all_agree', None) @property def has_field_exec_sub_type(self): if hasattr(self, '_m_has_field_exec_sub_type'): return self._m_has_field_exec_sub_type self._m_has_field_exec_sub_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_exec_sub_type', None) class EnumAudioVoiceTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AudioVoiceTrigger, self.data.value) return getattr(self, '_m_value', None) class FlightDailyPointFactor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_time_factor: self.time_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gold_factor: self.gold_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_time_factor(self): if hasattr(self, '_m_has_field_time_factor'): return self._m_has_field_time_factor self._m_has_field_time_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_time_factor', None) @property def has_field_gold_factor(self): if hasattr(self, '_m_has_field_gold_factor'): return self._m_has_field_gold_factor self._m_has_field_gold_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gold_factor', None) class ConfigGraphicsRecommendSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_performance_quality: self.performance_quality = AuxTypes.String(self._io, self, self._root) if self.has_field_virtual_joystick_radius: self.virtual_joystick_radius = self._io.read_f4le() if self.has_field_level_streaming_config: self.level_streaming_config = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_cache_config: self.ui_cache_config = AuxTypes.String(self._io, self, self._root) if self.has_field_light_on_level: self.light_on_level = Output.EnumLightLevel(self._io, self, self._root) if self.has_field_requirements: self.requirements = Output.ArrayOfConfigGraphicsRequirementLengthU(self._io, self, self._root) if self.has_field_texture_streaming_budget: self.texture_streaming_budget = self._io.read_f4le() if self.has_field_enable_cutscene_texture_streaming: self.enable_cutscene_texture_streaming = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_texture_streaming_enabled: self.texture_streaming_enabled = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_texture_streaming_offset: self.texture_streaming_offset = self._io.read_f4le() if self.has_field_enable_ui_camera_full_resolution: self.enable_ui_camera_full_resolution = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_preload_ui_scene: self.preload_ui_scene = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_disable_do_f: self.disable_do_f = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_enable_subpass: self.enable_subpass = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_per_object_light_in_forward: self.use_per_object_light_in_forward = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_render_resolutions: self.render_resolutions = Output.ArrayOfConfigRenderResolutionLengthU(self._io, self, self._root) if self.has_field_quality_level: self.quality_level = AuxTypes.String(self._io, self, self._root) if self.has_field_default_volatile_grade: self.default_volatile_grade = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_avatar_outline_thresh: self.avatar_outline_thresh = self._io.read_f4le() if self.has_field_avatar_shadow_thresh: self.avatar_shadow_thresh = self._io.read_f4le() if self.has_field_avatar_motion_vector_thresh: self.avatar_motion_vector_thresh = self._io.read_f4le() if self.has_field_view_distance_ratio: self.view_distance_ratio = self._io.read_f4le() if self.has_field_grass_quality: self.grass_quality = Output.EnumGrassQualityLevel(self._io, self, self._root) if self.has_field_crowd_spawn_distance: self.crowd_spawn_distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_crowd_despawn_distance: self.crowd_despawn_distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_entity_lod_config: self.entity_lod_config = AuxTypes.String(self._io, self, self._root) if self.has_field_device_extra_frame_rate: self.device_extra_frame_rate = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_override_render_res_grade: self.override_render_res_grade = Output.DictOfEnumVolatileTypeAuxTypesVlqBase128LeS(self._io, self, self._root) @property def has_field_texture_streaming_enabled(self): if hasattr(self, '_m_has_field_texture_streaming_enabled'): return self._m_has_field_texture_streaming_enabled self._m_has_field_texture_streaming_enabled = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_texture_streaming_enabled', None) @property def has_field_quality_level(self): if hasattr(self, '_m_has_field_quality_level'): return self._m_has_field_quality_level self._m_has_field_quality_level = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_quality_level', None) @property def has_field_virtual_joystick_radius(self): if hasattr(self, '_m_has_field_virtual_joystick_radius'): return self._m_has_field_virtual_joystick_radius self._m_has_field_virtual_joystick_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_virtual_joystick_radius', None) @property def has_field_device_extra_frame_rate(self): if hasattr(self, '_m_has_field_device_extra_frame_rate'): return self._m_has_field_device_extra_frame_rate self._m_has_field_device_extra_frame_rate = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_device_extra_frame_rate', None) @property def has_field_light_on_level(self): if hasattr(self, '_m_has_field_light_on_level'): return self._m_has_field_light_on_level self._m_has_field_light_on_level = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_light_on_level', None) @property def has_field_disable_do_f(self): if hasattr(self, '_m_has_field_disable_do_f'): return self._m_has_field_disable_do_f self._m_has_field_disable_do_f = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_disable_do_f', None) @property def has_field_enable_ui_camera_full_resolution(self): if hasattr(self, '_m_has_field_enable_ui_camera_full_resolution'): return self._m_has_field_enable_ui_camera_full_resolution self._m_has_field_enable_ui_camera_full_resolution = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_enable_ui_camera_full_resolution', None) @property def has_field_render_resolutions(self): if hasattr(self, '_m_has_field_render_resolutions'): return self._m_has_field_render_resolutions self._m_has_field_render_resolutions = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_render_resolutions', None) @property def has_field_override_render_res_grade(self): if hasattr(self, '_m_has_field_override_render_res_grade'): return self._m_has_field_override_render_res_grade self._m_has_field_override_render_res_grade = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_override_render_res_grade', None) @property def has_field_requirements(self): if hasattr(self, '_m_has_field_requirements'): return self._m_has_field_requirements self._m_has_field_requirements = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_requirements', None) @property def has_field_avatar_outline_thresh(self): if hasattr(self, '_m_has_field_avatar_outline_thresh'): return self._m_has_field_avatar_outline_thresh self._m_has_field_avatar_outline_thresh = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_avatar_outline_thresh', None) @property def has_field_texture_streaming_budget(self): if hasattr(self, '_m_has_field_texture_streaming_budget'): return self._m_has_field_texture_streaming_budget self._m_has_field_texture_streaming_budget = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_texture_streaming_budget', None) @property def has_field_entity_lod_config(self): if hasattr(self, '_m_has_field_entity_lod_config'): return self._m_has_field_entity_lod_config self._m_has_field_entity_lod_config = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_entity_lod_config', None) @property def has_field_use_per_object_light_in_forward(self): if hasattr(self, '_m_has_field_use_per_object_light_in_forward'): return self._m_has_field_use_per_object_light_in_forward self._m_has_field_use_per_object_light_in_forward = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_use_per_object_light_in_forward', None) @property def has_field_texture_streaming_offset(self): if hasattr(self, '_m_has_field_texture_streaming_offset'): return self._m_has_field_texture_streaming_offset self._m_has_field_texture_streaming_offset = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_texture_streaming_offset', None) @property def has_field_grass_quality(self): if hasattr(self, '_m_has_field_grass_quality'): return self._m_has_field_grass_quality self._m_has_field_grass_quality = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_grass_quality', None) @property def has_field_avatar_shadow_thresh(self): if hasattr(self, '_m_has_field_avatar_shadow_thresh'): return self._m_has_field_avatar_shadow_thresh self._m_has_field_avatar_shadow_thresh = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_avatar_shadow_thresh', None) @property def has_field_enable_subpass(self): if hasattr(self, '_m_has_field_enable_subpass'): return self._m_has_field_enable_subpass self._m_has_field_enable_subpass = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_enable_subpass', None) @property def has_field_view_distance_ratio(self): if hasattr(self, '_m_has_field_view_distance_ratio'): return self._m_has_field_view_distance_ratio self._m_has_field_view_distance_ratio = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_view_distance_ratio', None) @property def has_field_default_volatile_grade(self): if hasattr(self, '_m_has_field_default_volatile_grade'): return self._m_has_field_default_volatile_grade self._m_has_field_default_volatile_grade = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_default_volatile_grade', None) @property def has_field_ui_cache_config(self): if hasattr(self, '_m_has_field_ui_cache_config'): return self._m_has_field_ui_cache_config self._m_has_field_ui_cache_config = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_ui_cache_config', None) @property def has_field_crowd_spawn_distance(self): if hasattr(self, '_m_has_field_crowd_spawn_distance'): return self._m_has_field_crowd_spawn_distance self._m_has_field_crowd_spawn_distance = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_crowd_spawn_distance', None) @property def has_field_avatar_motion_vector_thresh(self): if hasattr(self, '_m_has_field_avatar_motion_vector_thresh'): return self._m_has_field_avatar_motion_vector_thresh self._m_has_field_avatar_motion_vector_thresh = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_avatar_motion_vector_thresh', None) @property def has_field_enable_cutscene_texture_streaming(self): if hasattr(self, '_m_has_field_enable_cutscene_texture_streaming'): return self._m_has_field_enable_cutscene_texture_streaming self._m_has_field_enable_cutscene_texture_streaming = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enable_cutscene_texture_streaming', None) @property def has_field_performance_quality(self): if hasattr(self, '_m_has_field_performance_quality'): return self._m_has_field_performance_quality self._m_has_field_performance_quality = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_performance_quality', None) @property def has_field_crowd_despawn_distance(self): if hasattr(self, '_m_has_field_crowd_despawn_distance'): return self._m_has_field_crowd_despawn_distance self._m_has_field_crowd_despawn_distance = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_crowd_despawn_distance', None) @property def has_field_preload_ui_scene(self): if hasattr(self, '_m_has_field_preload_ui_scene'): return self._m_has_field_preload_ui_scene self._m_has_field_preload_ui_scene = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_preload_ui_scene', None) @property def has_field_level_streaming_config(self): if hasattr(self, '_m_has_field_level_streaming_config'): return self._m_has_field_level_streaming_config self._m_has_field_level_streaming_config = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_level_streaming_config', None) class AttachModifierToSurfaceTypeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_surface_type: self.surface_type = Output.EnumSceneSurfaceType(self._io, self, self._root) if self.has_field_modifiers_with_predicates: self.modifiers_with_predicates = Output.ArrayOfModifierWithPredicatesLengthU(self._io, self, self._root) if self.has_field_extra_enter_trigger_level_ability: self.extra_enter_trigger_level_ability = AuxTypes.String(self._io, self, self._root) if self.has_field_extra_exit_trigger_level_ability: self.extra_exit_trigger_level_ability = AuxTypes.String(self._io, self, self._root) if self.has_field_extra_reset_trigger_level_ability: self.extra_reset_trigger_level_ability = AuxTypes.String(self._io, self, self._root) @property def has_field_modifiers_with_predicates(self): if hasattr(self, '_m_has_field_modifiers_with_predicates'): return self._m_has_field_modifiers_with_predicates self._m_has_field_modifiers_with_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifiers_with_predicates', None) @property def has_field_extra_enter_trigger_level_ability(self): if hasattr(self, '_m_has_field_extra_enter_trigger_level_ability'): return self._m_has_field_extra_enter_trigger_level_ability self._m_has_field_extra_enter_trigger_level_ability = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_extra_enter_trigger_level_ability', None) @property def has_field_extra_reset_trigger_level_ability(self): if hasattr(self, '_m_has_field_extra_reset_trigger_level_ability'): return self._m_has_field_extra_reset_trigger_level_ability self._m_has_field_extra_reset_trigger_level_ability = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_extra_reset_trigger_level_ability', None) @property def has_field_surface_type(self): if hasattr(self, '_m_has_field_surface_type'): return self._m_has_field_surface_type self._m_has_field_surface_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_surface_type', None) @property def has_field_extra_exit_trigger_level_ability(self): if hasattr(self, '_m_has_field_extra_exit_trigger_level_ability'): return self._m_has_field_extra_exit_trigger_level_ability self._m_has_field_extra_exit_trigger_level_ability = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_extra_exit_trigger_level_ability', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigVehicleStamina(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_stamina_upper_limit: self.stamina_upper_limit = self._io.read_f4le() if self.has_field_stamina_recover_speed: self.stamina_recover_speed = self._io.read_f4le() if self.has_field_stamina_recover_wait_time: self.stamina_recover_wait_time = self._io.read_f4le() if self.has_field_extra_stamina_upper_limit: self.extra_stamina_upper_limit = self._io.read_f4le() if self.has_field_sprint_stamina_cost: self.sprint_stamina_cost = self._io.read_f4le() if self.has_field_dash_stamina_cost: self.dash_stamina_cost = self._io.read_f4le() @property def has_field_stamina_recover_speed(self): if hasattr(self, '_m_has_field_stamina_recover_speed'): return self._m_has_field_stamina_recover_speed self._m_has_field_stamina_recover_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stamina_recover_speed', None) @property def has_field_sprint_stamina_cost(self): if hasattr(self, '_m_has_field_sprint_stamina_cost'): return self._m_has_field_sprint_stamina_cost self._m_has_field_sprint_stamina_cost = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_sprint_stamina_cost', None) @property def has_field_extra_stamina_upper_limit(self): if hasattr(self, '_m_has_field_extra_stamina_upper_limit'): return self._m_has_field_extra_stamina_upper_limit self._m_has_field_extra_stamina_upper_limit = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_extra_stamina_upper_limit', None) @property def has_field_dash_stamina_cost(self): if hasattr(self, '_m_has_field_dash_stamina_cost'): return self._m_has_field_dash_stamina_cost self._m_has_field_dash_stamina_cost = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_dash_stamina_cost', None) @property def has_field_stamina_upper_limit(self): if hasattr(self, '_m_has_field_stamina_upper_limit'): return self._m_has_field_stamina_upper_limit self._m_has_field_stamina_upper_limit = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stamina_upper_limit', None) @property def has_field_stamina_recover_wait_time(self): if hasattr(self, '_m_has_field_stamina_recover_wait_time'): return self._m_has_field_stamina_recover_wait_time self._m_has_field_stamina_recover_wait_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_stamina_recover_wait_time', None) class ConfigLogoPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_channel_name: self.channel_name = AuxTypes.String(self._io, self, self._root) if self.has_field_logo_file_name: self.logo_file_name = AuxTypes.String(self._io, self, self._root) if self.has_field_show_tip_text: self.show_tip_text = self._io.read_u1() if self.has_field_tip_text_map_id: self.tip_text_map_id = AuxTypes.String(self._io, self, self._root) if self.has_field_show_tip_img_aw: self.show_tip_img_aw = self._io.read_u1() if self.has_field_tip_img_aw_name: self.tip_img_aw_name = AuxTypes.String(self._io, self, self._root) if self.has_field_show_warning_view: self.show_warning_view = self._io.read_u1() if self.has_field_warning_title: self.warning_title = AuxTypes.String(self._io, self, self._root) if self.has_field_warning_desc: self.warning_desc = AuxTypes.String(self._io, self, self._root) if self.has_field_show_koran_tips_view: self.show_koran_tips_view = self._io.read_u1() if self.has_field_koran_tips_desc: self.koran_tips_desc = AuxTypes.String(self._io, self, self._root) @property def has_field_channel_name(self): if hasattr(self, '_m_has_field_channel_name'): return self._m_has_field_channel_name self._m_has_field_channel_name = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_channel_name', None) @property def has_field_tip_text_map_id(self): if hasattr(self, '_m_has_field_tip_text_map_id'): return self._m_has_field_tip_text_map_id self._m_has_field_tip_text_map_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_tip_text_map_id', None) @property def has_field_show_warning_view(self): if hasattr(self, '_m_has_field_show_warning_view'): return self._m_has_field_show_warning_view self._m_has_field_show_warning_view = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_show_warning_view', None) @property def has_field_show_tip_img_aw(self): if hasattr(self, '_m_has_field_show_tip_img_aw'): return self._m_has_field_show_tip_img_aw self._m_has_field_show_tip_img_aw = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_show_tip_img_aw', None) @property def has_field_koran_tips_desc(self): if hasattr(self, '_m_has_field_koran_tips_desc'): return self._m_has_field_koran_tips_desc self._m_has_field_koran_tips_desc = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_koran_tips_desc', None) @property def has_field_tip_img_aw_name(self): if hasattr(self, '_m_has_field_tip_img_aw_name'): return self._m_has_field_tip_img_aw_name self._m_has_field_tip_img_aw_name = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_tip_img_aw_name', None) @property def has_field_warning_desc(self): if hasattr(self, '_m_has_field_warning_desc'): return self._m_has_field_warning_desc self._m_has_field_warning_desc = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_warning_desc', None) @property def has_field_show_koran_tips_view(self): if hasattr(self, '_m_has_field_show_koran_tips_view'): return self._m_has_field_show_koran_tips_view self._m_has_field_show_koran_tips_view = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_show_koran_tips_view', None) @property def has_field_logo_file_name(self): if hasattr(self, '_m_has_field_logo_file_name'): return self._m_has_field_logo_file_name self._m_has_field_logo_file_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_logo_file_name', None) @property def has_field_warning_title(self): if hasattr(self, '_m_has_field_warning_title'): return self._m_has_field_warning_title self._m_has_field_warning_title = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_warning_title', None) @property def has_field_show_tip_text(self): if hasattr(self, '_m_has_field_show_tip_text'): return self._m_has_field_show_tip_text self._m_has_field_show_tip_text = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_show_tip_text', None) class RogueDiaryResourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGlobalValueTurn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetTurn(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_name: self.global_value_name = AuxTypes.String(self._io, self, self._root) if self.has_field_avatar_target_pos_gv_key_name: self.avatar_target_pos_gv_key_name = AuxTypes.String(self._io, self, self._root) if self.has_field_avatar_target_pos_map: self.avatar_target_pos_map = Output.DictOfAuxTypesVlqBase128LeUVector(self._io, self, self._root) @property def move_part_around_y(self): if hasattr(self, '_m_move_part_around_y'): return self._m_move_part_around_y self._m_move_part_around_y = self.base.move_part_around_y return getattr(self, '_m_move_part_around_y', None) @property def audio_stop_turning_event_around_x(self): if hasattr(self, '_m_audio_stop_turning_event_around_x'): return self._m_audio_stop_turning_event_around_x self._m_audio_stop_turning_event_around_x = self.base.audio_stop_turning_event_around_x return getattr(self, '_m_audio_stop_turning_event_around_x', None) @property def anchor_part_around_z(self): if hasattr(self, '_m_anchor_part_around_z'): return self._m_anchor_part_around_z self._m_anchor_part_around_z = self.base.anchor_part_around_z return getattr(self, '_m_anchor_part_around_z', None) @property def audio_stop_turning_event_around_z(self): if hasattr(self, '_m_audio_stop_turning_event_around_z'): return self._m_audio_stop_turning_event_around_z self._m_audio_stop_turning_event_around_z = self.base.audio_stop_turning_event_around_z return getattr(self, '_m_audio_stop_turning_event_around_z', None) @property def move_part_around_x(self): if hasattr(self, '_m_move_part_around_x'): return self._m_move_part_around_x self._m_move_part_around_x = self.base.move_part_around_x return getattr(self, '_m_move_part_around_x', None) @property def audio_begin_turning_event(self): if hasattr(self, '_m_audio_begin_turning_event'): return self._m_audio_begin_turning_event self._m_audio_begin_turning_event = self.base.audio_begin_turning_event return getattr(self, '_m_audio_begin_turning_event', None) @property def audio_stop_turning_event_around_y(self): if hasattr(self, '_m_audio_stop_turning_event_around_y'): return self._m_audio_stop_turning_event_around_y self._m_audio_stop_turning_event_around_y = self.base.audio_stop_turning_event_around_y return getattr(self, '_m_audio_stop_turning_event_around_y', None) @property def move_part_around_z(self): if hasattr(self, '_m_move_part_around_z'): return self._m_move_part_around_z self._m_move_part_around_z = self.base.move_part_around_z return getattr(self, '_m_move_part_around_z', None) @property def has_field_avatar_target_pos_map(self): if hasattr(self, '_m_has_field_avatar_target_pos_map'): return self._m_has_field_avatar_target_pos_map self._m_has_field_avatar_target_pos_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_avatar_target_pos_map', None) @property def audio_begin_turning_event_around_x(self): if hasattr(self, '_m_audio_begin_turning_event_around_x'): return self._m_audio_begin_turning_event_around_x self._m_audio_begin_turning_event_around_x = self.base.audio_begin_turning_event_around_x return getattr(self, '_m_audio_begin_turning_event_around_x', None) @property def audio_begin_turning_event_around_z(self): if hasattr(self, '_m_audio_begin_turning_event_around_z'): return self._m_audio_begin_turning_event_around_z self._m_audio_begin_turning_event_around_z = self.base.audio_begin_turning_event_around_z return getattr(self, '_m_audio_begin_turning_event_around_z', None) @property def anchor_part_around_x(self): if hasattr(self, '_m_anchor_part_around_x'): return self._m_anchor_part_around_x self._m_anchor_part_around_x = self.base.anchor_part_around_x return getattr(self, '_m_anchor_part_around_x', None) @property def audio_stop_turning_event(self): if hasattr(self, '_m_audio_stop_turning_event'): return self._m_audio_stop_turning_event self._m_audio_stop_turning_event = self.base.audio_stop_turning_event return getattr(self, '_m_audio_stop_turning_event', None) @property def audio_begin_turning_event_around_y(self): if hasattr(self, '_m_audio_begin_turning_event_around_y'): return self._m_audio_begin_turning_event_around_y self._m_audio_begin_turning_event_around_y = self.base.audio_begin_turning_event_around_y return getattr(self, '_m_audio_begin_turning_event_around_y', None) @property def has_field_avatar_target_pos_gv_key_name(self): if hasattr(self, '_m_has_field_avatar_target_pos_gv_key_name'): return self._m_has_field_avatar_target_pos_gv_key_name self._m_has_field_avatar_target_pos_gv_key_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_avatar_target_pos_gv_key_name', None) @property def anchor_part_around_y(self): if hasattr(self, '_m_anchor_part_around_y'): return self._m_anchor_part_around_y self._m_anchor_part_around_y = self.base.anchor_part_around_y return getattr(self, '_m_anchor_part_around_y', None) @property def has_field_global_value_name(self): if hasattr(self, '_m_has_field_global_value_name'): return self._m_has_field_global_value_name self._m_has_field_global_value_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_name', None) @property def turn_state_map(self): if hasattr(self, '_m_turn_state_map'): return self._m_turn_state_map self._m_turn_state_map = self.base.turn_state_map return getattr(self, '_m_turn_state_map', None) class ConfigCombatBeHit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hit_blood_effect: self.hit_blood_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_auto_redirect: self.hit_auto_redirect = self._io.read_u1() if self.has_field_mute_all_hit: self.mute_all_hit = self._io.read_u1() if self.has_field_mute_all_hit_effect: self.mute_all_hit_effect = self._io.read_u1() if self.has_field_mute_all_hit_text: self.mute_all_hit_text = self._io.read_u1() if self.has_field_ignore_min_hit_vy: self.ignore_min_hit_vy = self._io.read_u1() if self.has_field_blend_shake: self.blend_shake = Output.DispConfigBeHitBlendShake(self._io, self, self._root) @property def has_field_ignore_min_hit_vy(self): if hasattr(self, '_m_has_field_ignore_min_hit_vy'): return self._m_has_field_ignore_min_hit_vy self._m_has_field_ignore_min_hit_vy = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_ignore_min_hit_vy', None) @property def has_field_mute_all_hit_text(self): if hasattr(self, '_m_has_field_mute_all_hit_text'): return self._m_has_field_mute_all_hit_text self._m_has_field_mute_all_hit_text = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_mute_all_hit_text', None) @property def has_field_mute_all_hit(self): if hasattr(self, '_m_has_field_mute_all_hit'): return self._m_has_field_mute_all_hit self._m_has_field_mute_all_hit = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_mute_all_hit', None) @property def has_field_blend_shake(self): if hasattr(self, '_m_has_field_blend_shake'): return self._m_has_field_blend_shake self._m_has_field_blend_shake = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_blend_shake', None) @property def has_field_mute_all_hit_effect(self): if hasattr(self, '_m_has_field_mute_all_hit_effect'): return self._m_has_field_mute_all_hit_effect self._m_has_field_mute_all_hit_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_mute_all_hit_effect', None) @property def has_field_hit_blood_effect(self): if hasattr(self, '_m_has_field_hit_blood_effect'): return self._m_has_field_hit_blood_effect self._m_has_field_hit_blood_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_blood_effect', None) @property def has_field_hit_auto_redirect(self): if hasattr(self, '_m_has_field_hit_auto_redirect'): return self._m_has_field_hit_auto_redirect self._m_has_field_hit_auto_redirect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hit_auto_redirect', None) class TextParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BonusTreasureSolutionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigCrowdSceneTagRestrictionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdSceneTagRestriction(self._io, self, self._root)) class ConfigEntityCollider(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumEntityColliderType(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) class MechanicusDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExpeditionOpenCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExpeditionOpenCondType, self.data.value) return getattr(self, '_m_value', None) class SalvageStageDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_day: self.start_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_cond_id: self.unlock_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_land_group_link_list: self.land_group_link_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_sea_group_link_list: self.sea_group_link_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_unlock_challenge_group_link_list: self.unlock_challenge_group_link_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_salvage_challenge_id_list: self.salvage_challenge_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_salvage_challenge_id_list(self): if hasattr(self, '_m_has_field_salvage_challenge_id_list'): return self._m_has_field_salvage_challenge_id_list self._m_has_field_salvage_challenge_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_salvage_challenge_id_list', None) @property def has_field_unlock_challenge_group_link_list(self): if hasattr(self, '_m_has_field_unlock_challenge_group_link_list'): return self._m_has_field_unlock_challenge_group_link_list self._m_has_field_unlock_challenge_group_link_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_unlock_challenge_group_link_list', None) @property def has_field_land_group_link_list(self): if hasattr(self, '_m_has_field_land_group_link_list'): return self._m_has_field_land_group_link_list self._m_has_field_land_group_link_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_land_group_link_list', None) @property def has_field_sea_group_link_list(self): if hasattr(self, '_m_has_field_sea_group_link_list'): return self._m_has_field_sea_group_link_list self._m_has_field_sea_group_link_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sea_group_link_list', None) @property def has_field_unlock_cond_id(self): if hasattr(self, '_m_has_field_unlock_cond_id'): return self._m_has_field_unlock_cond_id self._m_has_field_unlock_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_cond_id', None) @property def has_field_start_day(self): if hasattr(self, '_m_has_field_start_day'): return self._m_has_field_start_day self._m_has_field_start_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_start_day', None) class ModifyExtraSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_delta: self.cd_delta = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cd_ratio: self.cd_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cd_min: self.cd_min = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def has_field_cd_min(self): if hasattr(self, '_m_has_field_cd_min'): return self._m_has_field_cd_min self._m_has_field_cd_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cd_min', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_cd_delta(self): if hasattr(self, '_m_has_field_cd_delta'): return self._m_has_field_cd_delta self._m_has_field_cd_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_delta', None) class SettingEntryDisplayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityShopOverallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldServerGadgetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByDieStateFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_die_state_flag: self.die_state_flag = Output.EnumDieStateFlag(self._io, self, self._root) @property def has_field_die_state_flag(self): if hasattr(self, '_m_has_field_die_state_flag'): return self._m_has_field_die_state_flag self._m_has_field_die_state_flag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_die_state_flag', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class SetSubWeaponEmissionScaler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_sub_weapons: self.sub_weapons = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_use_default_color: self.use_default_color = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_sub_weapons(self): if hasattr(self, '_m_has_field_sub_weapons'): return self._m_has_field_sub_weapons self._m_has_field_sub_weapons = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sub_weapons', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_use_default_color(self): if hasattr(self, '_m_has_field_use_default_color'): return self._m_has_field_use_default_color self._m_has_field_use_default_color = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_default_color', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class NewActivityAvatarSelectionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringArrayOfEnumTextLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfEnumTextLanguageTypeLengthU(self._io, self, self._root) class ConfigBattleFervorUpdateTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigBattleFervorUpdatePredicateLengthU(self._io, self, self._root) if self.has_field_delta_value: self.delta_value = self._io.read_f4le() @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_delta_value(self): if hasattr(self, '_m_has_field_delta_value'): return self._m_has_field_delta_value self._m_has_field_delta_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_delta_value', None) class CoopCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumCoopCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class ConfigQteStepPowerBarAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_change_value: self.change_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_change_value(self): if hasattr(self, '_m_has_field_change_value'): return self._m_has_field_change_value self._m_has_field_change_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_change_value', None) @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) class EnumRogueDiaryStageDifficultyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueDiaryStageDifficultyType, self.data.value) return getattr(self, '_m_value', None) class EnumWeaponType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WeaponType, self.data.value) return getattr(self, '_m_value', None) class EntityInVisibleMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_reason: self.reason = Output.EnumAbilityEntityVisibleReason(self._io, self, self._root) if self.has_field_disable_audio: self.disable_audio = self._io.read_u1() @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_reason(self): if hasattr(self, '_m_has_field_reason'): return self._m_has_field_reason self._m_has_field_reason = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reason', None) @property def has_field_disable_audio(self): if hasattr(self, '_m_has_field_disable_audio'): return self._m_has_field_disable_audio self._m_has_field_disable_audio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_disable_audio', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class TurnDirectionToPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_min_angle: self.min_angle = self._io.read_f4le() if self.has_field_max_angle: self.max_angle = self._io.read_f4le() @property def has_field_max_angle(self): if hasattr(self, '_m_has_field_max_angle'): return self._m_has_field_max_angle self._m_has_field_max_angle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_angle', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_min_angle(self): if hasattr(self, '_m_has_field_min_angle'): return self._m_has_field_min_angle self._m_has_field_min_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_angle', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_pos', None) class BrickRotateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SeaLampSectionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_section_id: self.section_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mini_quest_id: self.mini_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id_vec: self.watcher_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_watcher_id_vec(self): if hasattr(self, '_m_has_field_watcher_id_vec'): return self._m_has_field_watcher_id_vec self._m_has_field_watcher_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id_vec', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_section_id(self): if hasattr(self, '_m_has_field_section_id'): return self._m_has_field_section_id self._m_has_field_section_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_section_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_mini_quest_id(self): if hasattr(self, '_m_has_field_mini_quest_id'): return self._m_has_field_mini_quest_id self._m_has_field_mini_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mini_quest_id', None) class ByDungeonSettled(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumHideAndSeekSkillCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HideAndSeekSkillCategory, self.data.value) return getattr(self, '_m_value', None) class ComboConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_combo_up_limit: self.combo_up_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rate: self.rate = self._io.read_f4le() @property def has_field_combo_up_limit(self): if hasattr(self, '_m_has_field_combo_up_limit'): return self._m_has_field_combo_up_limit self._m_has_field_combo_up_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_combo_up_limit', None) @property def has_field_rate(self): if hasattr(self, '_m_has_field_rate'): return self._m_has_field_rate self._m_has_field_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_rate', None) class CustomSlotConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_slot_id: self.slot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_optional_parts_id_list: self.optional_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_necessary: self.is_necessary = self._io.read_u1() if self.has_field_default_parts_id_list: self.default_parts_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pass_part_id_list: self.pass_part_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_parts_id: self.init_parts_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_slot_id(self): if hasattr(self, '_m_has_field_slot_id'): return self._m_has_field_slot_id self._m_has_field_slot_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_slot_id', None) @property def has_field_default_parts_id_list(self): if hasattr(self, '_m_has_field_default_parts_id_list'): return self._m_has_field_default_parts_id_list self._m_has_field_default_parts_id_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_default_parts_id_list', None) @property def has_field_optional_parts_id_list(self): if hasattr(self, '_m_has_field_optional_parts_id_list'): return self._m_has_field_optional_parts_id_list self._m_has_field_optional_parts_id_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_optional_parts_id_list', None) @property def has_field_init_parts_id(self): if hasattr(self, '_m_has_field_init_parts_id'): return self._m_has_field_init_parts_id self._m_has_field_init_parts_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_init_parts_id', None) @property def has_field_is_necessary(self): if hasattr(self, '_m_has_field_is_necessary'): return self._m_has_field_is_necessary self._m_has_field_is_necessary = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_necessary', None) @property def has_field_pass_part_id_list(self): if hasattr(self, '_m_has_field_pass_part_id_list'): return self._m_has_field_pass_part_id_list self._m_has_field_pass_part_id_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_pass_part_id_list', None) class EnableCameraDof(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable_dof: self.enable_dof = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_enable_dof(self): if hasattr(self, '_m_has_field_enable_dof'): return self._m_has_field_enable_dof self._m_has_field_enable_dof = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable_dof', None) class ConfigKeyframe(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_in_tangent: self.in_tangent = self._io.read_f4le() if self.has_field_out_tangent: self.out_tangent = self._io.read_f4le() @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_in_tangent(self): if hasattr(self, '_m_has_field_in_tangent'): return self._m_has_field_in_tangent self._m_has_field_in_tangent = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_in_tangent', None) @property def has_field_out_tangent(self): if hasattr(self, '_m_has_field_out_tangent'): return self._m_has_field_out_tangent self._m_has_field_out_tangent = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_out_tangent', None) class WidgetOccupyTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiCombatRoleComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExpeditionChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QteStepCameraTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigEffectWithThresholdLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEffectWithThreshold(self._io, self, self._root)) class ConfigCrowdSceneTagRestriction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_tags: self.scene_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_active: self.is_active = self._io.read_u1() @property def has_field_scene_tags(self): if hasattr(self, '_m_has_field_scene_tags'): return self._m_has_field_scene_tags self._m_has_field_scene_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_tags', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_active', None) class ArrayOfCoopSelectNodeContentLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CoopSelectNodeContent(self._io, self, self._root)) class BlessingScanExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scan_type: self.scan_type = Output.EnumBlessingScanType(self._io, self, self._root) if self.has_field_ref_id: self.ref_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pic_up_config: self.pic_up_config = Output.ArrayOfBlessingPicUpConfigLengthS(self._io, self, self._root) if self.has_field_scan_duration: self.scan_duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scan_time: self.scan_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hit_boxes_node_name: self.hit_boxes_node_name = AuxTypes.String(self._io, self, self._root) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_scan_time(self): if hasattr(self, '_m_has_field_scan_time'): return self._m_has_field_scan_time self._m_has_field_scan_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_scan_time', None) @property def has_field_pic_up_config(self): if hasattr(self, '_m_has_field_pic_up_config'): return self._m_has_field_pic_up_config self._m_has_field_pic_up_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pic_up_config', None) @property def has_field_scan_type(self): if hasattr(self, '_m_has_field_scan_type'): return self._m_has_field_scan_type self._m_has_field_scan_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scan_type', None) @property def has_field_hit_boxes_node_name(self): if hasattr(self, '_m_has_field_hit_boxes_node_name'): return self._m_has_field_hit_boxes_node_name self._m_has_field_hit_boxes_node_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_hit_boxes_node_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_ref_id(self): if hasattr(self, '_m_has_field_ref_id'): return self._m_has_field_ref_id self._m_has_field_ref_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ref_id', None) @property def has_field_scan_duration(self): if hasattr(self, '_m_has_field_scan_duration'): return self._m_has_field_scan_duration self._m_has_field_scan_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_scan_duration', None) class ControlEmotion(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_toggle_emo_sync: self.toggle_emo_sync = self._io.read_u1() if self.has_field_toggle_blink: self.toggle_blink = self._io.read_u1() if self.has_field_toggle_eye_key: self.toggle_eye_key = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_toggle_emo_sync(self): if hasattr(self, '_m_has_field_toggle_emo_sync'): return self._m_has_field_toggle_emo_sync self._m_has_field_toggle_emo_sync = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_toggle_emo_sync', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_toggle_eye_key(self): if hasattr(self, '_m_has_field_toggle_eye_key'): return self._m_has_field_toggle_eye_key self._m_has_field_toggle_eye_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_toggle_eye_key', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_toggle_blink(self): if hasattr(self, '_m_has_field_toggle_blink'): return self._m_has_field_toggle_blink self._m_has_field_toggle_blink = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_toggle_blink', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DispConfigBaseAttackPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseAttackPattern(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigAttackBox(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigAttackSphere(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigAttackDoubleTrail(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigSimpleAttackPattern(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigAttackTrail(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigAttackCircle(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigAttackUsePrefab(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class AnimalCodexTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGachaStageTextExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_title: self.stage_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_desc1: self.stage_desc1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_desc2: self.stage_desc2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_desc3: self.stage_desc3 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_tips: self.quest_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_stage_desc3(self): if hasattr(self, '_m_has_field_stage_desc3'): return self._m_has_field_stage_desc3 self._m_has_field_stage_desc3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_stage_desc3', None) @property def has_field_stage_desc1(self): if hasattr(self, '_m_has_field_stage_desc1'): return self._m_has_field_stage_desc1 self._m_has_field_stage_desc1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stage_desc1', None) @property def has_field_quest_tips(self): if hasattr(self, '_m_has_field_quest_tips'): return self._m_has_field_quest_tips self._m_has_field_quest_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_tips', None) @property def has_field_stage_title(self): if hasattr(self, '_m_has_field_stage_title'): return self._m_has_field_stage_title self._m_has_field_stage_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_title', None) @property def has_field_stage_desc2(self): if hasattr(self, '_m_has_field_stage_desc2'): return self._m_has_field_stage_desc2 self._m_has_field_stage_desc2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stage_desc2', None) class SetRandomOverrideMapValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value_range_max: self.value_range_max = self._io.read_f4le() if self.has_field_value_range_min: self.value_range_min = self._io.read_f4le() if self.has_field_override_map_key: self.override_map_key = AuxTypes.String(self._io, self, self._root) if self.has_field_round_type: self.round_type = Output.EnumRoundRandomType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value_range_min(self): if hasattr(self, '_m_has_field_value_range_min'): return self._m_has_field_value_range_min self._m_has_field_value_range_min = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value_range_min', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_map_key(self): if hasattr(self, '_m_has_field_override_map_key'): return self._m_has_field_override_map_key self._m_has_field_override_map_key = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map_key', None) @property def has_field_round_type(self): if hasattr(self, '_m_has_field_round_type'): return self._m_has_field_round_type self._m_has_field_round_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_round_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_value_range_max(self): if hasattr(self, '_m_has_field_value_range_max'): return self._m_has_field_value_range_max self._m_has_field_value_range_max = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_range_max', None) class SetCombatFixedMovePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_point: self.set_point = self._io.read_u1() if self.has_field_to_pos: self.to_pos = Output.DispConfigBornType(self._io, self, self._root) @property def has_field_set_point(self): if hasattr(self, '_m_has_field_set_point'): return self._m_has_field_set_point self._m_has_field_set_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_point', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_to_pos(self): if hasattr(self, '_m_has_field_to_pos'): return self._m_has_field_to_pos self._m_has_field_to_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_pos', None) class EnumProjectionGameGuideFinishType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProjectionGameGuideFinishType, self.data.value) return getattr(self, '_m_value', None) class ExclusiveRuleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExpeditionActivityMarkerExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandTaskLevelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_zone_level: self.min_zone_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_zone_level: self.max_zone_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_min_zone_level(self): if hasattr(self, '_m_has_field_min_zone_level'): return self._m_has_field_min_zone_level self._m_has_field_min_zone_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_min_zone_level', None) @property def has_field_max_zone_level(self): if hasattr(self, '_m_has_field_max_zone_level'): return self._m_has_field_max_zone_level self._m_has_field_max_zone_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_zone_level', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_revise_level', None) class SetSkillCanUseInStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_list: self.skill_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_state_list: self.state_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_skill_list(self): if hasattr(self, '_m_has_field_skill_list'): return self._m_has_field_skill_list self._m_has_field_skill_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_list', None) @property def has_field_state_list(self): if hasattr(self, '_m_has_field_state_list'): return self._m_has_field_state_list self._m_has_field_state_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAudioIndex(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ambience: self.ambience = AuxTypes.String(self._io, self, self._root) if self.has_field_avatar: self.avatar = AuxTypes.String(self._io, self, self._root) if self.has_field_avatar_move: self.avatar_move = AuxTypes.String(self._io, self, self._root) if self.has_field_base_move: self.base_move = AuxTypes.String(self._io, self, self._root) if self.has_field_city_blocks: self.city_blocks = AuxTypes.String(self._io, self, self._root) if self.has_field_camera: self.camera = AuxTypes.String(self._io, self, self._root) if self.has_field_combat: self.combat = AuxTypes.String(self._io, self, self._root) if self.has_field_dialog: self.dialog = AuxTypes.String(self._io, self, self._root) if self.has_field_element_reactions: self.element_reactions = AuxTypes.String(self._io, self, self._root) if self.has_field_gadget: self.gadget = AuxTypes.String(self._io, self, self._root) if self.has_field_view_state: self.view_state = AuxTypes.String(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.String(self._io, self, self._root) if self.has_field_listener: self.listener = AuxTypes.String(self._io, self, self._root) if self.has_field_map_info: self.map_info = AuxTypes.String(self._io, self, self._root) if self.has_field_music: self.music = AuxTypes.String(self._io, self, self._root) if self.has_field_mutual_exclusions: self.mutual_exclusions = AuxTypes.String(self._io, self, self._root) if self.has_field_npc: self.npc = AuxTypes.String(self._io, self, self._root) if self.has_field_quest: self.quest = AuxTypes.String(self._io, self, self._root) if self.has_field_resource: self.resource = AuxTypes.String(self._io, self, self._root) if self.has_field_surface_type: self.surface_type = AuxTypes.String(self._io, self, self._root) if self.has_field_ui: self.ui = AuxTypes.String(self._io, self, self._root) if self.has_field_weather: self.weather = AuxTypes.String(self._io, self, self._root) if self.has_field_speech: self.speech = AuxTypes.String(self._io, self, self._root) @property def has_field_quest(self): if hasattr(self, '_m_has_field_quest'): return self._m_has_field_quest self._m_has_field_quest = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_quest', None) @property def has_field_gadget(self): if hasattr(self, '_m_has_field_gadget'): return self._m_has_field_gadget self._m_has_field_gadget = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_gadget', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_combat(self): if hasattr(self, '_m_has_field_combat'): return self._m_has_field_combat self._m_has_field_combat = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_combat', None) @property def has_field_avatar(self): if hasattr(self, '_m_has_field_avatar'): return self._m_has_field_avatar self._m_has_field_avatar = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_avatar', None) @property def has_field_listener(self): if hasattr(self, '_m_has_field_listener'): return self._m_has_field_listener self._m_has_field_listener = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_listener', None) @property def has_field_map_info(self): if hasattr(self, '_m_has_field_map_info'): return self._m_has_field_map_info self._m_has_field_map_info = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_map_info', None) @property def has_field_resource(self): if hasattr(self, '_m_has_field_resource'): return self._m_has_field_resource self._m_has_field_resource = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_resource', None) @property def has_field_dialog(self): if hasattr(self, '_m_has_field_dialog'): return self._m_has_field_dialog self._m_has_field_dialog = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_dialog', None) @property def has_field_speech(self): if hasattr(self, '_m_has_field_speech'): return self._m_has_field_speech self._m_has_field_speech = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_speech', None) @property def has_field_camera(self): if hasattr(self, '_m_has_field_camera'): return self._m_has_field_camera self._m_has_field_camera = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_camera', None) @property def has_field_weather(self): if hasattr(self, '_m_has_field_weather'): return self._m_has_field_weather self._m_has_field_weather = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_weather', None) @property def has_field_element_reactions(self): if hasattr(self, '_m_has_field_element_reactions'): return self._m_has_field_element_reactions self._m_has_field_element_reactions = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_element_reactions', None) @property def has_field_view_state(self): if hasattr(self, '_m_has_field_view_state'): return self._m_has_field_view_state self._m_has_field_view_state = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_view_state', None) @property def has_field_music(self): if hasattr(self, '_m_has_field_music'): return self._m_has_field_music self._m_has_field_music = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_music', None) @property def has_field_mutual_exclusions(self): if hasattr(self, '_m_has_field_mutual_exclusions'): return self._m_has_field_mutual_exclusions self._m_has_field_mutual_exclusions = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_mutual_exclusions', None) @property def has_field_npc(self): if hasattr(self, '_m_has_field_npc'): return self._m_has_field_npc self._m_has_field_npc = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_npc', None) @property def has_field_surface_type(self): if hasattr(self, '_m_has_field_surface_type'): return self._m_has_field_surface_type self._m_has_field_surface_type = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_surface_type', None) @property def has_field_ui(self): if hasattr(self, '_m_has_field_ui'): return self._m_has_field_ui self._m_has_field_ui = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_ui', None) @property def has_field_ambience(self): if hasattr(self, '_m_has_field_ambience'): return self._m_has_field_ambience self._m_has_field_ambience = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_ambience', None) @property def has_field_base_move(self): if hasattr(self, '_m_has_field_base_move'): return self._m_has_field_base_move self._m_has_field_base_move = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_base_move', None) @property def has_field_avatar_move(self): if hasattr(self, '_m_has_field_avatar_move'): return self._m_has_field_avatar_move self._m_has_field_avatar_move = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_avatar_move', None) @property def has_field_city_blocks(self): if hasattr(self, '_m_has_field_city_blocks'): return self._m_has_field_city_blocks self._m_has_field_city_blocks = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_city_blocks', None) class ArrayOfConfigLocalGadgetMoveOpLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLocalGadgetMoveOp(self._io, self, self._root)) class EnumEntityAppearVisionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityAppearVisionType, self.data.value) return getattr(self, '_m_value', None) class BattlePassStoryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_unlock_level: self.story_unlock_level = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_story_id: self.story_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_story_title: self.story_title = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_story_unlock_level(self): if hasattr(self, '_m_has_field_story_unlock_level'): return self._m_has_field_story_unlock_level self._m_has_field_story_unlock_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_story_unlock_level', None) @property def has_field_story_id(self): if hasattr(self, '_m_has_field_story_id'): return self._m_has_field_story_id self._m_has_field_story_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_story_id', None) @property def has_field_story_title(self): if hasattr(self, '_m_has_field_story_title'): return self._m_has_field_story_title self._m_has_field_story_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_story_title', None) class DungeonQuitPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_size', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class VoiceSegmentItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopActivityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_activity_name: self.activity_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_des: self.activity_des = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_activity_name(self): if hasattr(self, '_m_has_field_activity_name'): return self._m_has_field_activity_name self._m_has_field_activity_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_activity_name', None) @property def has_field_activity_des(self): if hasattr(self, '_m_has_field_activity_des'): return self._m_has_field_activity_des self._m_has_field_activity_des = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_activity_des', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_prefab_path', None) class KvpOfDictAuxTypesVlqBase128LeUCoopSavePoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.CoopSavePoint(self._io, self, self._root) class EnumLanV2projectionRootPointMotionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LanV2projectionRootPointMotionType, self.data.value) return getattr(self, '_m_value', None) class LanV2fireworksOverallDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_init_stamina_value: self.init_stamina_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fire_element_addition_list: self.fire_element_addition_list = Output.ArrayOfFireElementAdditionConfigLengthS(self._io, self, self._root) if self.has_field_score_formula_exponent: self.score_formula_exponent = self._io.read_f4le() if self.has_field_score_formula_offset: self.score_formula_offset = self._io.read_f4le() if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_fire_element_addition_list(self): if hasattr(self, '_m_has_field_fire_element_addition_list'): return self._m_has_field_fire_element_addition_list self._m_has_field_fire_element_addition_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_fire_element_addition_list', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_init_stamina_value(self): if hasattr(self, '_m_has_field_init_stamina_value'): return self._m_has_field_init_stamina_value self._m_has_field_init_stamina_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_init_stamina_value', None) @property def has_field_score_formula_exponent(self): if hasattr(self, '_m_has_field_score_formula_exponent'): return self._m_has_field_score_formula_exponent self._m_has_field_score_formula_exponent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_score_formula_exponent', None) @property def has_field_score_formula_offset(self): if hasattr(self, '_m_has_field_score_formula_offset'): return self._m_has_field_score_formula_offset self._m_has_field_score_formula_offset = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_score_formula_offset', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) class MonsterReadyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_monster_ready: self.on_monster_ready = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_on_monster_ready(self): if hasattr(self, '_m_has_field_on_monster_ready'): return self._m_has_field_on_monster_ready self._m_has_field_on_monster_ready = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_monster_ready', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfConfigInputHintLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigInputHint(self._io, self, self._root)) class ActivityBannerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumReputationEntranceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReputationEntranceType, self.data.value) return getattr(self, '_m_value', None) class EnumMultiPositionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MultiPositionType, self.data.value) return getattr(self, '_m_value', None) class HideAndSeekSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueCellWeightExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfHandbookQuestGuideShowCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.HandbookQuestGuideShowCond(self._io, self, self._root)) class RendererFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ConfigWidgetAddBuff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_buff_id', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class ArrayOfConfigAudioStateGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAudioStateGroup(self._io, self, self._root)) class ConfigPerfBoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_device_spec_item: self.device_spec_item = Output.DictOfAuxTypesStringU1(self._io, self, self._root) if self.has_field_item_option_map: self.item_option_map = Output.DictOfAuxTypesStringConfigPerfBoolItemOptionArrayInfo(self._io, self, self._root) if self.has_field_override_map: self.override_map = Output.DictOfAuxTypesStringConfigPerfBoolItemOverrideInfo(self._io, self, self._root) @property def has_field_item_option_map(self): if hasattr(self, '_m_has_field_item_option_map'): return self._m_has_field_item_option_map self._m_has_field_item_option_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_option_map', None) @property def player_custom_option(self): if hasattr(self, '_m_player_custom_option'): return self._m_player_custom_option self._m_player_custom_option = self.base.player_custom_option return getattr(self, '_m_player_custom_option', None) @property def category_rating_map(self): if hasattr(self, '_m_category_rating_map'): return self._m_category_rating_map self._m_category_rating_map = self.base.category_rating_map return getattr(self, '_m_category_rating_map', None) @property def has_field_override_map(self): if hasattr(self, '_m_has_field_override_map'): return self._m_has_field_override_map self._m_has_field_override_map = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_override_map', None) @property def has_field_device_spec_item(self): if hasattr(self, '_m_has_field_device_spec_item'): return self._m_has_field_device_spec_item self._m_has_field_device_spec_item = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_device_spec_item', None) class EnumRadarHintType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RadarHintType, self.data.value) return getattr(self, '_m_value', None) class ConfigBlackScreenAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_black_screen_type: self.black_screen_type = Output.EnumBlackScreenType(self._io, self, self._root) if self.has_field_duration_to_black: self.duration_to_black = self._io.read_f4le() if self.has_field_duration_keep_black: self.duration_keep_black = self._io.read_f4le() if self.has_field_duration_from_black: self.duration_from_black = self._io.read_f4le() if self.has_field_change_to_intee_pos: self.change_to_intee_pos = self._io.read_u1() if self.has_field_intee_pos: self.intee_pos = AuxTypes.String(self._io, self, self._root) if self.has_field_text_map_id: self.text_map_id = AuxTypes.String(self._io, self, self._root) if self.has_field_text_shake: self.text_shake = self._io.read_u1() if self.has_field_use_white_screen: self.use_white_screen = self._io.read_u1() if self.has_field_use_text_fade: self.use_text_fade = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_wait_click: self.need_wait_click = self._io.read_u1() if self.has_field_show_click_btn_delay_time: self.show_click_btn_delay_time = self._io.read_f4le() @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def has_field_text_map_id(self): if hasattr(self, '_m_has_field_text_map_id'): return self._m_has_field_text_map_id self._m_has_field_text_map_id = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_text_map_id', None) @property def has_field_need_wait_click(self): if hasattr(self, '_m_has_field_need_wait_click'): return self._m_has_field_need_wait_click self._m_has_field_need_wait_click = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_need_wait_click', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_duration_from_black(self): if hasattr(self, '_m_has_field_duration_from_black'): return self._m_has_field_duration_from_black self._m_has_field_duration_from_black = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_duration_from_black', None) @property def has_field_text_shake(self): if hasattr(self, '_m_has_field_text_shake'): return self._m_has_field_text_shake self._m_has_field_text_shake = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_text_shake', None) @property def has_field_duration_keep_black(self): if hasattr(self, '_m_has_field_duration_keep_black'): return self._m_has_field_duration_keep_black self._m_has_field_duration_keep_black = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_duration_keep_black', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_intee_pos(self): if hasattr(self, '_m_has_field_intee_pos'): return self._m_has_field_intee_pos self._m_has_field_intee_pos = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_intee_pos', None) @property def has_field_use_text_fade(self): if hasattr(self, '_m_has_field_use_text_fade'): return self._m_has_field_use_text_fade self._m_has_field_use_text_fade = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_use_text_fade', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_show_click_btn_delay_time(self): if hasattr(self, '_m_has_field_show_click_btn_delay_time'): return self._m_has_field_show_click_btn_delay_time self._m_has_field_show_click_btn_delay_time = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_show_click_btn_delay_time', None) @property def has_field_use_white_screen(self): if hasattr(self, '_m_has_field_use_white_screen'): return self._m_has_field_use_white_screen self._m_has_field_use_white_screen = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_use_white_screen', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_change_to_intee_pos(self): if hasattr(self, '_m_has_field_change_to_intee_pos'): return self._m_has_field_change_to_intee_pos self._m_has_field_change_to_intee_pos = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_change_to_intee_pos', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_duration_to_black(self): if hasattr(self, '_m_has_field_duration_to_black'): return self._m_has_field_duration_to_black self._m_has_field_duration_to_black = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_duration_to_black', None) @property def has_field_black_screen_type(self): if hasattr(self, '_m_has_field_black_screen_type'): return self._m_has_field_black_screen_type self._m_has_field_black_screen_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_black_screen_type', None) class NpcExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_json_path_hash: self.json_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_path_hash: self.json_path_hash_pre = self._io.read_s1() if self.has_field_alias: self.alias = AuxTypes.String(self._io, self, self._root) if self.has_field_script_data_path: self.script_data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_lua_data_path: self.lua_data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_lua_data_index: self.lua_data_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_has_combat: self.has_combat = self._io.read_u1() if self.has_field_has_move: self.has_move = self._io.read_u1() if self.has_field_has_audio: self.has_audio = self._io.read_u1() if self.has_field_is_daily: self.is_daily = self._io.read_u1() if self.has_field_dye_part: self.dye_part = AuxTypes.String(self._io, self, self._root) if self.has_field_billboard_type: self.billboard_type = Output.EnumBillboardType(self._io, self, self._root) if self.has_field_billboard_icon: self.billboard_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_invisiable: self.invisiable = self._io.read_u1() if self.has_field_disable_show_name: self.disable_show_name = self._io.read_u1() if self.has_field_template_emotion_path: self.template_emotion_path = AuxTypes.String(self._io, self, self._root) if self.has_field_animator_config_path_hash: self.animator_config_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_animator_config_path_hash: self.animator_config_path_hash_pre = self._io.read_s1() if self.has_field_body_type: self.body_type = Output.EnumNpcBodyType(self._io, self, self._root) if self.has_field_first_met_id: self.first_met_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unique_body_id: self.unique_body_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_activity_daily_npc: self.is_activity_daily_npc = self._io.read_u1() if self.has_field_use_dyn_bone: self.use_dyn_bone = self._io.read_u1() if self.has_field_skip_init_closet_to_ground: self.skip_init_closet_to_ground = self._io.read_u1() if self.has_field_is_release: self.is_release = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_pre = self._io.read_s1() if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_pre = self._io.read_s1() if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_pre = self._io.read_s1() if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_lua_data_index(self): if hasattr(self, '_m_has_field_lua_data_index'): return self._m_has_field_lua_data_index self._m_has_field_lua_data_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_lua_data_index', None) @property def has_field_billboard_icon(self): if hasattr(self, '_m_has_field_billboard_icon'): return self._m_has_field_billboard_icon self._m_has_field_billboard_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_billboard_icon', None) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_camp_id', None) @property def has_field_template_emotion_path(self): if hasattr(self, '_m_has_field_template_emotion_path'): return self._m_has_field_template_emotion_path self._m_has_field_template_emotion_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_template_emotion_path', None) @property def has_field_dye_part(self): if hasattr(self, '_m_has_field_dye_part'): return self._m_has_field_dye_part self._m_has_field_dye_part = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_dye_part', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_first_met_id(self): if hasattr(self, '_m_has_field_first_met_id'): return self._m_has_field_first_met_id self._m_has_field_first_met_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_first_met_id', None) @property def has_field_is_release(self): if hasattr(self, '_m_has_field_is_release'): return self._m_has_field_is_release self._m_has_field_is_release = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_is_release', None) @property def has_field_has_move(self): if hasattr(self, '_m_has_field_has_move'): return self._m_has_field_has_move self._m_has_field_has_move = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_has_move', None) @property def has_field_skip_init_closet_to_ground(self): if hasattr(self, '_m_has_field_skip_init_closet_to_ground'): return self._m_has_field_skip_init_closet_to_ground self._m_has_field_skip_init_closet_to_ground = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_skip_init_closet_to_ground', None) @property def has_field_script_data_path(self): if hasattr(self, '_m_has_field_script_data_path'): return self._m_has_field_script_data_path self._m_has_field_script_data_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_script_data_path', None) @property def has_field_lua_data_path(self): if hasattr(self, '_m_has_field_lua_data_path'): return self._m_has_field_lua_data_path self._m_has_field_lua_data_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_lua_data_path', None) @property def has_field_disable_show_name(self): if hasattr(self, '_m_has_field_disable_show_name'): return self._m_has_field_disable_show_name self._m_has_field_disable_show_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_disable_show_name', None) @property def has_field_has_combat(self): if hasattr(self, '_m_has_field_has_combat'): return self._m_has_field_has_combat self._m_has_field_has_combat = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_has_combat', None) @property def has_field_has_audio(self): if hasattr(self, '_m_has_field_has_audio'): return self._m_has_field_has_audio self._m_has_field_has_audio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_has_audio', None) @property def has_field_body_type(self): if hasattr(self, '_m_has_field_body_type'): return self._m_has_field_body_type self._m_has_field_body_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_body_type', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_is_daily(self): if hasattr(self, '_m_has_field_is_daily'): return self._m_has_field_is_daily self._m_has_field_is_daily = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_is_daily', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_is_activity_daily_npc(self): if hasattr(self, '_m_has_field_is_activity_daily_npc'): return self._m_has_field_is_activity_daily_npc self._m_has_field_is_activity_daily_npc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_is_activity_daily_npc', None) @property def has_field_invisiable(self): if hasattr(self, '_m_has_field_invisiable'): return self._m_has_field_invisiable self._m_has_field_invisiable = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_invisiable', None) @property def has_field_alias(self): if hasattr(self, '_m_has_field_alias'): return self._m_has_field_alias self._m_has_field_alias = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_alias', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_animator_config_path_hash(self): if hasattr(self, '_m_has_field_animator_config_path_hash'): return self._m_has_field_animator_config_path_hash self._m_has_field_animator_config_path_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_animator_config_path_hash', None) @property def has_field_use_dyn_bone(self): if hasattr(self, '_m_has_field_use_dyn_bone'): return self._m_has_field_use_dyn_bone self._m_has_field_use_dyn_bone = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_use_dyn_bone', None) @property def has_field_json_path_hash(self): if hasattr(self, '_m_has_field_json_path_hash'): return self._m_has_field_json_path_hash self._m_has_field_json_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_json_path_hash', None) @property def has_field_unique_body_id(self): if hasattr(self, '_m_has_field_unique_body_id'): return self._m_has_field_unique_body_id self._m_has_field_unique_body_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_unique_body_id', None) @property def has_field_billboard_type(self): if hasattr(self, '_m_has_field_billboard_type'): return self._m_has_field_billboard_type self._m_has_field_billboard_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_billboard_type', None) class ArrayOfConfigHomeworldFurnitureUnitLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldFurnitureUnit(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeSConfigAiExtractionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiExtractionData(self._io, self, self._root) class ConfigHomeFurniture(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spawn_pos: self.spawn_pos = Output.Vector(self._io, self, self._root) if self.has_field_spawn_rot: self.spawn_rot = Output.Vector(self._io, self, self._root) if self.has_field_parent_furniture_index: self.parent_furniture_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_spawn_pos(self): if hasattr(self, '_m_has_field_spawn_pos'): return self._m_has_field_spawn_pos self._m_has_field_spawn_pos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_pos', None) @property def has_field_spawn_rot(self): if hasattr(self, '_m_has_field_spawn_rot'): return self._m_has_field_spawn_rot self._m_has_field_spawn_rot = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_spawn_rot', None) @property def has_field_parent_furniture_index(self): if hasattr(self, '_m_has_field_parent_furniture_index'): return self._m_has_field_parent_furniture_index self._m_has_field_parent_furniture_index = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_parent_furniture_index', None) class WorldAreaConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_type: self.area_type = Output.EnumWorldAreaType(self._io, self, self._root) if self.has_field_area_id_1: self.area_id_1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id_2: self.area_id_2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_default_lock: self.area_default_lock = self._io.read_u1() if self.has_field_area_name: self.area_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tower_point_id: self.tower_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_terrain_type: self.terrain_type = Output.EnumAreaTerrainType(self._io, self, self._root) if self.has_field_show_tips: self.show_tips = self._io.read_u1() if self.has_field_minimap_scale: self.minimap_scale = self._io.read_f4le() @property def has_field_area_type(self): if hasattr(self, '_m_has_field_area_type'): return self._m_has_field_area_type self._m_has_field_area_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_area_type', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_area_id_2(self): if hasattr(self, '_m_has_field_area_id_2'): return self._m_has_field_area_id_2 self._m_has_field_area_id_2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_area_id_2', None) @property def has_field_area_id_1(self): if hasattr(self, '_m_has_field_area_id_1'): return self._m_has_field_area_id_1 self._m_has_field_area_id_1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_area_id_1', None) @property def has_field_area_default_lock(self): if hasattr(self, '_m_has_field_area_default_lock'): return self._m_has_field_area_default_lock self._m_has_field_area_default_lock = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_area_default_lock', None) @property def has_field_tower_point_id(self): if hasattr(self, '_m_has_field_tower_point_id'): return self._m_has_field_tower_point_id self._m_has_field_tower_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_tower_point_id', None) @property def has_field_show_tips(self): if hasattr(self, '_m_has_field_show_tips'): return self._m_has_field_show_tips self._m_has_field_show_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_show_tips', None) @property def has_field_minimap_scale(self): if hasattr(self, '_m_has_field_minimap_scale'): return self._m_has_field_minimap_scale self._m_has_field_minimap_scale = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_minimap_scale', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_area_name(self): if hasattr(self, '_m_has_field_area_name'): return self._m_has_field_area_name self._m_has_field_area_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_area_name', None) @property def has_field_terrain_type(self): if hasattr(self, '_m_has_field_terrain_type'): return self._m_has_field_terrain_type self._m_has_field_terrain_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_terrain_type', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_element_type', None) class TeamResonanceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPropType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PropType, self.data.value) return getattr(self, '_m_value', None) class EquipAffixExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigStateCameraParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_radius_spring_ratio: self.radius_spring_ratio = self._io.read_f4le() if self.has_field_combat_elev_with_height_ratio: self.combat_elev_with_height_ratio = self._io.read_f4le() if self.has_field_force_radius: self.force_radius = self._io.read_f4le() if self.has_field_force_radius_duration: self.force_radius_duration = self._io.read_f4le() if self.has_field_should_keep_force_radius: self.should_keep_force_radius = self._io.read_u1() @property def has_field_force_radius_duration(self): if hasattr(self, '_m_has_field_force_radius_duration'): return self._m_has_field_force_radius_duration self._m_has_field_force_radius_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_force_radius_duration', None) @property def has_field_combat_elev_with_height_ratio(self): if hasattr(self, '_m_has_field_combat_elev_with_height_ratio'): return self._m_has_field_combat_elev_with_height_ratio self._m_has_field_combat_elev_with_height_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_combat_elev_with_height_ratio', None) @property def has_field_should_keep_force_radius(self): if hasattr(self, '_m_has_field_should_keep_force_radius'): return self._m_has_field_should_keep_force_radius self._m_has_field_should_keep_force_radius = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_should_keep_force_radius', None) @property def has_field_force_radius(self): if hasattr(self, '_m_has_field_force_radius'): return self._m_has_field_force_radius self._m_has_field_force_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_force_radius', None) @property def has_field_radius_spring_ratio(self): if hasattr(self, '_m_has_field_radius_spring_ratio'): return self._m_has_field_radius_spring_ratio self._m_has_field_radius_spring_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius_spring_ratio', None) class ConfigAiGroupSurroundSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiGroupSurroundData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiGroupSurroundData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class DictOfAuxTypesStringDispContextCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispContextCondition(self._io, self, self._root)) class OraionokamiDescExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_desc_id: self.desc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_content: self.desc_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_desc_id(self): if hasattr(self, '_m_has_field_desc_id'): return self._m_has_field_desc_id self._m_has_field_desc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_desc_id', None) @property def has_field_desc_content(self): if hasattr(self, '_m_has_field_desc_content'): return self._m_has_field_desc_content self._m_has_field_desc_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc_content', None) class ArrayOfDispConfigBaseGadgetTriggerActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigBaseGadgetTriggerAction(self._io, self, self._root)) class TeamResonanceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_team_resonance_id: self.team_resonance_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_team_resonance_group_id: self.team_resonance_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fire_avatar_count: self.fire_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_water_avatar_count: self.water_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grass_avatar_count: self.grass_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_electric_avatar_count: self.electric_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ice_avatar_count: self.ice_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_wind_avatar_count: self.wind_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rock_avatar_count: self.rock_avatar_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond: self.cond = Output.EnumTeamResonanceCondType(self._io, self, self._root) if self.has_field_min_total_promote_level: self.min_total_promote_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_config: self.open_config = AuxTypes.String(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_ice_avatar_count(self): if hasattr(self, '_m_has_field_ice_avatar_count'): return self._m_has_field_ice_avatar_count self._m_has_field_ice_avatar_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_ice_avatar_count', None) @property def has_field_open_config(self): if hasattr(self, '_m_has_field_open_config'): return self._m_has_field_open_config self._m_has_field_open_config = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_open_config', None) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_team_resonance_id(self): if hasattr(self, '_m_has_field_team_resonance_id'): return self._m_has_field_team_resonance_id self._m_has_field_team_resonance_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_team_resonance_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_min_total_promote_level(self): if hasattr(self, '_m_has_field_min_total_promote_level'): return self._m_has_field_min_total_promote_level self._m_has_field_min_total_promote_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_min_total_promote_level', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_param_list', None) @property def has_field_grass_avatar_count(self): if hasattr(self, '_m_has_field_grass_avatar_count'): return self._m_has_field_grass_avatar_count self._m_has_field_grass_avatar_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_grass_avatar_count', None) @property def has_field_rock_avatar_count(self): if hasattr(self, '_m_has_field_rock_avatar_count'): return self._m_has_field_rock_avatar_count self._m_has_field_rock_avatar_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_rock_avatar_count', None) @property def has_field_electric_avatar_count(self): if hasattr(self, '_m_has_field_electric_avatar_count'): return self._m_has_field_electric_avatar_count self._m_has_field_electric_avatar_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_electric_avatar_count', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_wind_avatar_count(self): if hasattr(self, '_m_has_field_wind_avatar_count'): return self._m_has_field_wind_avatar_count self._m_has_field_wind_avatar_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_wind_avatar_count', None) @property def has_field_team_resonance_group_id(self): if hasattr(self, '_m_has_field_team_resonance_group_id'): return self._m_has_field_team_resonance_group_id self._m_has_field_team_resonance_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_team_resonance_group_id', None) @property def has_field_water_avatar_count(self): if hasattr(self, '_m_has_field_water_avatar_count'): return self._m_has_field_water_avatar_count self._m_has_field_water_avatar_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_water_avatar_count', None) @property def has_field_fire_avatar_count(self): if hasattr(self, '_m_has_field_fire_avatar_count'): return self._m_has_field_fire_avatar_count self._m_has_field_fire_avatar_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_fire_avatar_count', None) class SelectTargetsBySelfGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_operation: self.operation = Output.EnumBitwiseOperator(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dynamic_value: self.dynamic_value = AuxTypes.DynamicInt(self._io, self, self._root) if self.has_field_use_binary: self.use_binary = self._io.read_u1() if self.has_field_compare_type: self.compare_type = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_dynamic_value(self): if hasattr(self, '_m_has_field_dynamic_value'): return self._m_has_field_dynamic_value self._m_has_field_dynamic_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_dynamic_value', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) @property def has_field_compare_type(self): if hasattr(self, '_m_has_field_compare_type'): return self._m_has_field_compare_type self._m_has_field_compare_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_compare_type', None) @property def has_field_use_binary(self): if hasattr(self, '_m_has_field_use_binary'): return self._m_has_field_use_binary self._m_has_field_use_binary = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_binary', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def has_field_operation(self): if hasattr(self, '_m_has_field_operation'): return self._m_has_field_operation self._m_has_field_operation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_operation', None) class EnumJsonClimateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.JsonClimateType, self.data.value) return getattr(self, '_m_value', None) class ApplyLevelModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class EnumChessCardNumericalModificationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChessCardNumericalModificationType, self.data.value) return getattr(self, '_m_value', None) class EnumBlackScreenType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlackScreenType, self.data.value) return getattr(self, '_m_value', None) class ConfigActionButton(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumActionBtnType(self._io, self, self._root) if self.has_field_force_show: self.force_show = self._io.read_u1() if self.has_field_only_handle_input: self.only_handle_input = self._io.read_u1() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_force_show(self): if hasattr(self, '_m_has_field_force_show'): return self._m_has_field_force_show self._m_has_field_force_show = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_force_show', None) @property def has_field_only_handle_input(self): if hasattr(self, '_m_has_field_only_handle_input'): return self._m_has_field_only_handle_input self._m_has_field_only_handle_input = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_only_handle_input', None) class ByTargetIsGhostToEnemy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumCompareProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CompareProperty, self.data.value) return getattr(self, '_m_value', None) class ConfigCannon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_close_operation_page_after_fire: self.close_operation_page_after_fire = self._io.read_u1() if self.has_field_close_page_delay: self.close_page_delay = self._io.read_f4le() if self.has_field_reminder_vanish_delay: self.reminder_vanish_delay = self._io.read_f4le() if self.has_field_fire_interval: self.fire_interval = self._io.read_f4le() if self.has_field_turning_btn_press_block_time: self.turning_btn_press_block_time = self._io.read_f4le() if self.has_field_reminder_text_map: self.reminder_text_map = AuxTypes.String(self._io, self, self._root) if self.has_field_turn_up_ability_name: self.turn_up_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_turn_down_ability_name: self.turn_down_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_turn_left_ability_name: self.turn_left_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_turn_right_ability_name: self.turn_right_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_fire_ability_name: self.fire_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_release_occupy_ability_name: self.release_occupy_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_occupy_gv_name: self.occupy_gv_name = AuxTypes.String(self._io, self, self._root) if self.has_field_fire_btn_icon: self.fire_btn_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_btn_element_color_index: self.btn_element_color_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_turn_up_ability_name(self): if hasattr(self, '_m_has_field_turn_up_ability_name'): return self._m_has_field_turn_up_ability_name self._m_has_field_turn_up_ability_name = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_turn_up_ability_name', None) @property def has_field_reminder_text_map(self): if hasattr(self, '_m_has_field_reminder_text_map'): return self._m_has_field_reminder_text_map self._m_has_field_reminder_text_map = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_reminder_text_map', None) @property def has_field_turn_right_ability_name(self): if hasattr(self, '_m_has_field_turn_right_ability_name'): return self._m_has_field_turn_right_ability_name self._m_has_field_turn_right_ability_name = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_turn_right_ability_name', None) @property def has_field_release_occupy_ability_name(self): if hasattr(self, '_m_has_field_release_occupy_ability_name'): return self._m_has_field_release_occupy_ability_name self._m_has_field_release_occupy_ability_name = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_release_occupy_ability_name', None) @property def has_field_fire_interval(self): if hasattr(self, '_m_has_field_fire_interval'): return self._m_has_field_fire_interval self._m_has_field_fire_interval = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_fire_interval', None) @property def has_field_turn_down_ability_name(self): if hasattr(self, '_m_has_field_turn_down_ability_name'): return self._m_has_field_turn_down_ability_name self._m_has_field_turn_down_ability_name = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_turn_down_ability_name', None) @property def has_field_close_operation_page_after_fire(self): if hasattr(self, '_m_has_field_close_operation_page_after_fire'): return self._m_has_field_close_operation_page_after_fire self._m_has_field_close_operation_page_after_fire = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_close_operation_page_after_fire', None) @property def has_field_turn_left_ability_name(self): if hasattr(self, '_m_has_field_turn_left_ability_name'): return self._m_has_field_turn_left_ability_name self._m_has_field_turn_left_ability_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_turn_left_ability_name', None) @property def has_field_close_page_delay(self): if hasattr(self, '_m_has_field_close_page_delay'): return self._m_has_field_close_page_delay self._m_has_field_close_page_delay = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_close_page_delay', None) @property def has_field_btn_element_color_index(self): if hasattr(self, '_m_has_field_btn_element_color_index'): return self._m_has_field_btn_element_color_index self._m_has_field_btn_element_color_index = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_btn_element_color_index', None) @property def has_field_fire_btn_icon(self): if hasattr(self, '_m_has_field_fire_btn_icon'): return self._m_has_field_fire_btn_icon self._m_has_field_fire_btn_icon = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_fire_btn_icon', None) @property def has_field_occupy_gv_name(self): if hasattr(self, '_m_has_field_occupy_gv_name'): return self._m_has_field_occupy_gv_name self._m_has_field_occupy_gv_name = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_occupy_gv_name', None) @property def has_field_turning_btn_press_block_time(self): if hasattr(self, '_m_has_field_turning_btn_press_block_time'): return self._m_has_field_turning_btn_press_block_time self._m_has_field_turning_btn_press_block_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_turning_btn_press_block_time', None) @property def has_field_reminder_vanish_delay(self): if hasattr(self, '_m_has_field_reminder_vanish_delay'): return self._m_has_field_reminder_vanish_delay self._m_has_field_reminder_vanish_delay = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_reminder_vanish_delay', None) @property def has_field_fire_ability_name(self): if hasattr(self, '_m_has_field_fire_ability_name'): return self._m_has_field_fire_ability_name self._m_has_field_fire_ability_name = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_fire_ability_name', None) class FindHilichurlHiliWeiExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_duration_hint: self.duration_hint = AuxTypes.String(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position_center: self.position_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_position_radius: self.position_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_position_radius(self): if hasattr(self, '_m_has_field_position_radius'): return self._m_has_field_position_radius self._m_has_field_position_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_position_radius', None) @property def has_field_duration_hint(self): if hasattr(self, '_m_has_field_duration_hint'): return self._m_has_field_duration_hint self._m_has_field_duration_hint = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_duration_hint', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_position_center(self): if hasattr(self, '_m_has_field_position_center'): return self._m_has_field_position_center self._m_has_field_position_center = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_position_center', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) class DungeonElementChallengeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_id: self.trial_avatar_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_trial_avatar_id(self): if hasattr(self, '_m_has_field_trial_avatar_id'): return self._m_has_field_trial_avatar_id self._m_has_field_trial_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_trial_avatar_id', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) class ReputationLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_level_exp: self.next_level_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_request_group_id: self.request_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_request_num: self.request_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_request_accept_num: self.request_accept_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_function_id: self.function_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_request_num(self): if hasattr(self, '_m_has_field_request_num'): return self._m_has_field_request_num self._m_has_field_request_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_request_num', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_request_accept_num(self): if hasattr(self, '_m_has_field_request_accept_num'): return self._m_has_field_request_accept_num self._m_has_field_request_accept_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_request_accept_num', None) @property def has_field_request_group_id(self): if hasattr(self, '_m_has_field_request_group_id'): return self._m_has_field_request_group_id self._m_has_field_request_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_request_group_id', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_next_level_exp(self): if hasattr(self, '_m_has_field_next_level_exp'): return self._m_has_field_next_level_exp self._m_has_field_next_level_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_next_level_exp', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_function_id(self): if hasattr(self, '_m_has_field_function_id'): return self._m_has_field_function_id self._m_has_field_function_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_function_id', None) class DispConfigBaseCutscene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseCutscene(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigTimeline(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class FetterInfoExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProjectionGameGuideTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueCellWeightExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_spring_weight: self.spring_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_store_weight: self.store_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_elite_weight: self.elite_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_spring_weight(self): if hasattr(self, '_m_has_field_spring_weight'): return self._m_has_field_spring_weight self._m_has_field_spring_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_spring_weight', None) @property def has_field_store_weight(self): if hasattr(self, '_m_has_field_store_weight'): return self._m_has_field_store_weight self._m_has_field_store_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_store_weight', None) @property def has_field_elite_weight(self): if hasattr(self, '_m_has_field_elite_weight'): return self._m_has_field_elite_weight self._m_has_field_elite_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_elite_weight', None) class ConfigWhiteList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_full_tick_modifiers: self.full_tick_modifiers = Output.DictOfAuxTypesStringDictOfAuxTypesStringF4(self._io, self, self._root) @property def has_field_full_tick_modifiers(self): if hasattr(self, '_m_has_field_full_tick_modifiers'): return self._m_has_field_full_tick_modifiers self._m_has_field_full_tick_modifiers = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_full_tick_modifiers', None) class ChannellerSlabLoopDungeonConditionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSceneSubType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneSubType, self.data.value) return getattr(self, '_m_value', None) class EnumMaterialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MaterialType, self.data.value) return getattr(self, '_m_value', None) class MonsterSecurityLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGachaBaseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_elem_time: self.elem_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_content_id: self.task_content_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_stage_id: self.unlock_stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_convert: self.max_convert = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_limit: self.robot_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_guar_num: self.robot_guar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_hidden_first_guar_num: self.robot_hidden_first_guar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_hidden_guar_num: self.robot_hidden_guar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_guar_rate: self.robot_guar_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_robot_hidden_guar_rate: self.robot_hidden_guar_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_list: self.quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reminder_id: self.reminder_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exchange_tips_cond: self.exchange_tips_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_free_mode_unlock_quest: self.free_mode_unlock_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_elem_time(self): if hasattr(self, '_m_has_field_elem_time'): return self._m_has_field_elem_time self._m_has_field_elem_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_elem_time', None) @property def has_field_quest_list(self): if hasattr(self, '_m_has_field_quest_list'): return self._m_has_field_quest_list self._m_has_field_quest_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_quest_list', None) @property def has_field_task_content_id(self): if hasattr(self, '_m_has_field_task_content_id'): return self._m_has_field_task_content_id self._m_has_field_task_content_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_task_content_id', None) @property def has_field_free_mode_unlock_quest(self): if hasattr(self, '_m_has_field_free_mode_unlock_quest'): return self._m_has_field_free_mode_unlock_quest self._m_has_field_free_mode_unlock_quest = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_free_mode_unlock_quest', None) @property def has_field_reminder_id(self): if hasattr(self, '_m_has_field_reminder_id'): return self._m_has_field_reminder_id self._m_has_field_reminder_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_reminder_id', None) @property def has_field_robot_hidden_first_guar_num(self): if hasattr(self, '_m_has_field_robot_hidden_first_guar_num'): return self._m_has_field_robot_hidden_first_guar_num self._m_has_field_robot_hidden_first_guar_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_robot_hidden_first_guar_num', None) @property def has_field_robot_guar_rate(self): if hasattr(self, '_m_has_field_robot_guar_rate'): return self._m_has_field_robot_guar_rate self._m_has_field_robot_guar_rate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_robot_guar_rate', None) @property def has_field_robot_hidden_guar_num(self): if hasattr(self, '_m_has_field_robot_hidden_guar_num'): return self._m_has_field_robot_hidden_guar_num self._m_has_field_robot_hidden_guar_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_robot_hidden_guar_num', None) @property def has_field_max_convert(self): if hasattr(self, '_m_has_field_max_convert'): return self._m_has_field_max_convert self._m_has_field_max_convert = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_max_convert', None) @property def has_field_robot_guar_num(self): if hasattr(self, '_m_has_field_robot_guar_num'): return self._m_has_field_robot_guar_num self._m_has_field_robot_guar_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_robot_guar_num', None) @property def has_field_unlock_stage_id(self): if hasattr(self, '_m_has_field_unlock_stage_id'): return self._m_has_field_unlock_stage_id self._m_has_field_unlock_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_stage_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_exchange_tips_cond(self): if hasattr(self, '_m_has_field_exchange_tips_cond'): return self._m_has_field_exchange_tips_cond self._m_has_field_exchange_tips_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_exchange_tips_cond', None) @property def has_field_robot_limit(self): if hasattr(self, '_m_has_field_robot_limit'): return self._m_has_field_robot_limit self._m_has_field_robot_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_robot_limit', None) @property def has_field_robot_hidden_guar_rate(self): if hasattr(self, '_m_has_field_robot_hidden_guar_rate'): return self._m_has_field_robot_hidden_guar_rate self._m_has_field_robot_hidden_guar_rate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_robot_hidden_guar_rate', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) class VoiceOutputMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTweenEaseType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TweenEaseType, self.data.value) return getattr(self, '_m_value', None) class MechanicusMapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mechanicus_map_id: self.mechanicus_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_name: self.map_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_tips: self.unlock_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_icon_path: self.map_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_build_gear_limit: self.build_gear_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_map_name(self): if hasattr(self, '_m_has_field_map_name'): return self._m_has_field_map_name self._m_has_field_map_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_map_name', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_mechanicus_map_id(self): if hasattr(self, '_m_has_field_mechanicus_map_id'): return self._m_has_field_mechanicus_map_id self._m_has_field_mechanicus_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mechanicus_map_id', None) @property def has_field_unlock_tips(self): if hasattr(self, '_m_has_field_unlock_tips'): return self._m_has_field_unlock_tips self._m_has_field_unlock_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_tips', None) @property def has_field_map_icon_path(self): if hasattr(self, '_m_has_field_map_icon_path'): return self._m_has_field_map_icon_path self._m_has_field_map_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_map_icon_path', None) @property def has_field_build_gear_limit(self): if hasattr(self, '_m_has_field_build_gear_limit'): return self._m_has_field_build_gear_limit self._m_has_field_build_gear_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_build_gear_limit', None) class ArrayOfRoutineCondContentLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RoutineCondContent(self._io, self, self._root)) class ConfigWidgetUseItemToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class AttachToElementTypeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_types: self.element_types = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_reject: self.reject = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_element_types(self): if hasattr(self, '_m_has_field_element_types'): return self._m_has_field_element_types self._m_has_field_element_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_types', None) @property def has_field_reject(self): if hasattr(self, '_m_has_field_reject'): return self._m_has_field_reject self._m_has_field_reject = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reject', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumMarkPluginIconType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkPluginIconType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumOptionTypeConfigParticleEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumOptionType(self._io, self, self._root) self.value = Output.ConfigParticleEffectSetting(self._io, self, self._root) class EliteShieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_shield_type: self.shield_type = AuxTypes.String(self._io, self, self._root) if self.has_field_shield_angle: self.shield_angle = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp_ratio: self.shield_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_shield_hp: self.shield_hp = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cost_shield_ratio_name: self.cost_shield_ratio_name = AuxTypes.String(self._io, self, self._root) if self.has_field_show_damage_text: self.show_damage_text = AuxTypes.String(self._io, self, self._root) if self.has_field_on_shield_broken: self.on_shield_broken = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_amount_by_get_damage: self.amount_by_get_damage = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_target_mute_hit_effect: self.target_mute_hit_effect = self._io.read_u1() if self.has_field_infinite_shield: self.infinite_shield = self._io.read_u1() if self.has_field_heal_limited_by_caster_max_hp_ratio: self.heal_limited_by_caster_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_target_mute_hit_effect(self): if hasattr(self, '_m_has_field_target_mute_hit_effect'): return self._m_has_field_target_mute_hit_effect self._m_has_field_target_mute_hit_effect = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_target_mute_hit_effect', None) @property def has_field_shield_type(self): if hasattr(self, '_m_has_field_shield_type'): return self._m_has_field_shield_type self._m_has_field_shield_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_shield_type', None) @property def has_field_infinite_shield(self): if hasattr(self, '_m_has_field_infinite_shield'): return self._m_has_field_infinite_shield self._m_has_field_infinite_shield = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_infinite_shield', None) @property def has_field_cost_shield_ratio_name(self): if hasattr(self, '_m_has_field_cost_shield_ratio_name'): return self._m_has_field_cost_shield_ratio_name self._m_has_field_cost_shield_ratio_name = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_cost_shield_ratio_name', None) @property def has_field_on_shield_broken(self): if hasattr(self, '_m_has_field_on_shield_broken'): return self._m_has_field_on_shield_broken self._m_has_field_on_shield_broken = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_on_shield_broken', None) @property def has_field_heal_limited_by_caster_max_hp_ratio(self): if hasattr(self, '_m_has_field_heal_limited_by_caster_max_hp_ratio'): return self._m_has_field_heal_limited_by_caster_max_hp_ratio self._m_has_field_heal_limited_by_caster_max_hp_ratio = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_heal_limited_by_caster_max_hp_ratio', None) @property def has_field_shield_angle(self): if hasattr(self, '_m_has_field_shield_angle'): return self._m_has_field_shield_angle self._m_has_field_shield_angle = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_shield_angle', None) @property def has_field_show_damage_text(self): if hasattr(self, '_m_has_field_show_damage_text'): return self._m_has_field_show_damage_text self._m_has_field_show_damage_text = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_damage_text', None) @property def has_field_shield_hp_ratio(self): if hasattr(self, '_m_has_field_shield_hp_ratio'): return self._m_has_field_shield_hp_ratio self._m_has_field_shield_hp_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shield_hp_ratio', None) @property def has_field_shield_hp(self): if hasattr(self, '_m_has_field_shield_hp'): return self._m_has_field_shield_hp self._m_has_field_shield_hp = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shield_hp', None) @property def has_field_amount_by_get_damage(self): if hasattr(self, '_m_has_field_amount_by_get_damage'): return self._m_has_field_amount_by_get_damage self._m_has_field_amount_by_get_damage = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_amount_by_get_damage', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfIndicatorLogicLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IndicatorLogic(self._io, self, self._root)) class EnumTokenForceEnqueueReason(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TokenForceEnqueueReason, self.data.value) return getattr(self, '_m_value', None) class ConfigAiFishingBitesBaitData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ActivityPotionBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param: self.desc_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_icon_hash: self.icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_hash: self.icon_hash_pre = self._io.read_s1() if self.has_field_buff_element: self.buff_element = AuxTypes.String(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc_param(self): if hasattr(self, '_m_has_field_desc_param'): return self._m_has_field_desc_param self._m_has_field_desc_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc_param', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quality', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_buff_id', None) @property def has_field_icon_hash(self): if hasattr(self, '_m_has_field_icon_hash'): return self._m_has_field_icon_hash self._m_has_field_icon_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_icon_hash', None) @property def has_field_buff_element(self): if hasattr(self, '_m_has_field_buff_element'): return self._m_has_field_buff_element self._m_has_field_buff_element = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_buff_element', None) class UnstickActionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class VoiceLanguageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicInstrumentConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMarkGlobal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_mark_icon_config: self.mark_icon_config = Output.DictOfEnumMarkIconTypeConfigMarkIcon(self._io, self, self._root) if self.has_field_custom_mark_icons: self.custom_mark_icons = Output.ArrayOfEnumMarkIconTypeLengthU(self._io, self, self._root) if self.has_field_scene_building_marks: self.scene_building_marks = Output.DictOfEnumSceneBuildingTypeEnumMarkIconType(self._io, self, self._root) if self.has_field_mark_order_to_layer_map: self.mark_order_to_layer_map = Output.DictOfEnumMarkOrderAuxTypesVlqBase128LeS(self._io, self, self._root) @property def has_field_mark_icon_config(self): if hasattr(self, '_m_has_field_mark_icon_config'): return self._m_has_field_mark_icon_config self._m_has_field_mark_icon_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mark_icon_config', None) @property def has_field_custom_mark_icons(self): if hasattr(self, '_m_has_field_custom_mark_icons'): return self._m_has_field_custom_mark_icons self._m_has_field_custom_mark_icons = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_custom_mark_icons', None) @property def has_field_scene_building_marks(self): if hasattr(self, '_m_has_field_scene_building_marks'): return self._m_has_field_scene_building_marks self._m_has_field_scene_building_marks = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scene_building_marks', None) @property def has_field_mark_order_to_layer_map(self): if hasattr(self, '_m_has_field_mark_order_to_layer_map'): return self._m_has_field_mark_order_to_layer_map self._m_has_field_mark_order_to_layer_map = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_mark_order_to_layer_map', None) class FishStockExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumFishStockType(self._io, self, self._root) if self.has_field_fish_weight: self.fish_weight = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_fish_weight(self): if hasattr(self, '_m_has_field_fish_weight'): return self._m_has_field_fish_weight self._m_has_field_fish_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_fish_weight', None) class ChannellerSlabLoopDungeonPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entry_desc: self.entry_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_entry_desc(self): if hasattr(self, '_m_has_field_entry_desc'): return self._m_has_field_entry_desc self._m_has_field_entry_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_entry_desc', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class WatcherSystemListenTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QteStepButtonSlideDirectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiBuddySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_buddy_feature_tag_i_ds: self.buddy_feature_tag_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def has_field_buddy_feature_tag_i_ds(self): if hasattr(self, '_m_has_field_buddy_feature_tag_i_ds'): return self._m_has_field_buddy_feature_tag_i_ds self._m_has_field_buddy_feature_tag_i_ds = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_buddy_feature_tag_i_ds', None) class ReliquaryMainPropExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prop_depot_id: self.prop_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prop_type: self.prop_type = Output.EnumFightPropType(self._io, self, self._root) if self.has_field_affix_name: self.affix_name = Output.EnumReliquaryMainAffixName(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_prop_depot_id(self): if hasattr(self, '_m_has_field_prop_depot_id'): return self._m_has_field_prop_depot_id self._m_has_field_prop_depot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prop_depot_id', None) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_prop_type', None) @property def has_field_affix_name(self): if hasattr(self, '_m_has_field_affix_name'): return self._m_has_field_affix_name self._m_has_field_affix_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_affix_name', None) class BlitzRushStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumConfigKeyCodeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumConfigKeyCode(self._io, self, self._root) self.value = AuxTypes.String(self._io, self, self._root) class DictOfEnumElementTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementTypeAuxTypesString(self._io, self, self._root)) class QteExec(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQteActionType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ExpeditionDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityRefJump(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_event_to_jump: self.event_to_jump = AuxTypes.String(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_event_to_jump(self): if hasattr(self, '_m_has_field_event_to_jump'): return self._m_has_field_event_to_jump self._m_has_field_event_to_jump = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_to_jump', None) class HomeWorldComfortLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_comfort: self.comfort = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_home_coin_produce_rate: self.home_coin_produce_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_companionship_exp_produce_rate: self.companionship_exp_produce_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_icon_hash: self.level_icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_icon_hash: self.level_icon_hash_pre = self._io.read_s1() @property def has_field_comfort(self): if hasattr(self, '_m_has_field_comfort'): return self._m_has_field_comfort self._m_has_field_comfort = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_comfort', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_home_coin_produce_rate(self): if hasattr(self, '_m_has_field_home_coin_produce_rate'): return self._m_has_field_home_coin_produce_rate self._m_has_field_home_coin_produce_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_home_coin_produce_rate', None) @property def has_field_companionship_exp_produce_rate(self): if hasattr(self, '_m_has_field_companionship_exp_produce_rate'): return self._m_has_field_companionship_exp_produce_rate self._m_has_field_companionship_exp_produce_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_companionship_exp_produce_rate', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_level_icon_hash(self): if hasattr(self, '_m_has_field_level_icon_hash'): return self._m_has_field_level_icon_hash self._m_has_field_level_icon_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level_icon_hash', None) class DungeonTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetCanDieImmediately(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_die_immediately: self.die_immediately = self._io.read_u1() @property def has_field_die_immediately(self): if hasattr(self, '_m_has_field_die_immediately'): return self._m_has_field_die_immediately self._m_has_field_die_immediately = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_die_immediately', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictEnumPlayModeTypeConfigActionPanelMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPlayModeType(self._io, self, self._root) self.value = Output.ConfigActionPanelMode(self._io, self, self._root) class NewActivityPushTipsConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MainCoopExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MistTrialClientSyncTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EndureTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWeekendDjinn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_spawn_pos: self.spawn_pos = Output.Vector(self._io, self, self._root) if self.has_field_spawn_rot: self.spawn_rot = Output.Vector(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) @property def has_field_spawn_pos(self): if hasattr(self, '_m_has_field_spawn_pos'): return self._m_has_field_spawn_pos self._m_has_field_spawn_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_spawn_pos', None) @property def has_field_spawn_rot(self): if hasattr(self, '_m_has_field_spawn_rot'): return self._m_has_field_spawn_rot self._m_has_field_spawn_rot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_spawn_rot', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_rot', None) class ArrayOfConfigRandomQuestSchemeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRandomQuestScheme(self._io, self, self._root)) class FlightActivityMedalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_medal_icon: self.medal_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_daily_info: self.daily_info = Output.ArrayOfFlightDailyInfoLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_medal_icon(self): if hasattr(self, '_m_has_field_medal_icon'): return self._m_has_field_medal_icon self._m_has_field_medal_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_medal_icon', None) @property def has_field_daily_info(self): if hasattr(self, '_m_has_field_daily_info'): return self._m_has_field_daily_info self._m_has_field_daily_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_daily_info', None) class ConfigGraphicsSettingEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entry_type: self.entry_type = Output.EnumGraphicsSettingEntryType(self._io, self, self._root) if self.has_field_available_options: self.available_options = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_perf_cost_ratios: self.perf_cost_ratios = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_display_type: self.display_type = Output.EnumSettingEntryDisplayType(self._io, self, self._root) if self.has_field_slider_min: self.slider_min = self._io.read_f4le() if self.has_field_slider_max: self.slider_max = self._io.read_f4le() if self.has_field_slider_interval: self.slider_interval = self._io.read_f4le() if self.has_field_should_cloud_game_show: self.should_cloud_game_show = self._io.read_u1() if self.has_field_sort_option: self.sort_option = Output.EnumConfigGraphicSettingEntrySortType(self._io, self, self._root) @property def has_field_slider_min(self): if hasattr(self, '_m_has_field_slider_min'): return self._m_has_field_slider_min self._m_has_field_slider_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_slider_min', None) @property def has_field_entry_type(self): if hasattr(self, '_m_has_field_entry_type'): return self._m_has_field_entry_type self._m_has_field_entry_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_entry_type', None) @property def has_field_should_cloud_game_show(self): if hasattr(self, '_m_has_field_should_cloud_game_show'): return self._m_has_field_should_cloud_game_show self._m_has_field_should_cloud_game_show = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_should_cloud_game_show', None) @property def has_field_slider_interval(self): if hasattr(self, '_m_has_field_slider_interval'): return self._m_has_field_slider_interval self._m_has_field_slider_interval = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_slider_interval', None) @property def has_field_sort_option(self): if hasattr(self, '_m_has_field_sort_option'): return self._m_has_field_sort_option self._m_has_field_sort_option = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_sort_option', None) @property def has_field_available_options(self): if hasattr(self, '_m_has_field_available_options'): return self._m_has_field_available_options self._m_has_field_available_options = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_available_options', None) @property def has_field_display_type(self): if hasattr(self, '_m_has_field_display_type'): return self._m_has_field_display_type self._m_has_field_display_type = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_display_type', None) @property def has_field_slider_max(self): if hasattr(self, '_m_has_field_slider_max'): return self._m_has_field_slider_max self._m_has_field_slider_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_slider_max', None) @property def has_field_perf_cost_ratios(self): if hasattr(self, '_m_has_field_perf_cost_ratios'): return self._m_has_field_perf_cost_ratios self._m_has_field_perf_cost_ratios = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_perf_cost_ratios', None) class ArrayOfU1LengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(self._io.read_u1()) class KvpOfDictAuxTypesStringConfigAttackEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigAttackEvent(self._io, self, self._root) class RegionSearchTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ResetAiResistTauntLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_resist_taunt_level: self.resist_taunt_level = Output.EnumTauntLevel(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_resist_taunt_level(self): if hasattr(self, '_m_has_field_resist_taunt_level'): return self._m_has_field_resist_taunt_level self._m_has_field_resist_taunt_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_resist_taunt_level', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfReunionPrivilegeConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ReunionPrivilegeConfig(self._io, self, self._root)) class ArrayOfConfigLevelMonsterUnitLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelMonsterUnit(self._io, self, self._root)) class EnumLocalGadgetCmdExeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LocalGadgetCmdExeType, self.data.value) return getattr(self, '_m_value', None) class EnumEntityAttackFilter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityAttackFilter, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigBaseContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigBaseContext(self._io, self, self._root) class BounceConjuringChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomRefreshTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RouteRecordModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoomRotateGadgetStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_type: self.trigger_type = Output.EnumEntityTriggerType(self._io, self, self._root) if self.has_field_trigger_flag: self.trigger_flag = Output.EnumTriggerFlag(self._io, self, self._root) if self.has_field_concern_type: self.concern_type = Output.EnumConcernType(self._io, self, self._root) if self.has_field_shape: self.shape = AuxTypes.String(self._io, self, self._root) if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_eular_offset: self.eular_offset = Output.Vector(self._io, self, self._root) if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_from_shape: self.from_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_from_offset: self.from_offset = Output.Vector(self._io, self, self._root) if self.has_field_from_eular_offset: self.from_eular_offset = Output.Vector(self._io, self, self._root) if self.has_field_from_height: self.from_height = self._io.read_f4le() if self.has_field_check_infinite: self.check_infinite = self._io.read_u1() if self.has_field_trigger_infinite: self.trigger_infinite = self._io.read_u1() if self.has_field_life_infinite: self.life_infinite = self._io.read_u1() if self.has_field_start_check_time: self.start_check_time = self._io.read_f4le() if self.has_field_check_interval: self.check_interval = self._io.read_f4le() if self.has_field_check_count: self.check_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trigger_interval: self.trigger_interval = self._io.read_f4le() if self.has_field_trigger_count: self.trigger_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_life_time: self.life_time = self._io.read_f4le() if self.has_field_overwrite_camp_type: self.overwrite_camp_type = self._io.read_u1() if self.has_field_camp_type: self.camp_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_check_point: self.check_point = self._io.read_u1() if self.has_field_use_surface_height: self.use_surface_height = self._io.read_u1() if self.has_field_use_collider: self.use_collider = self._io.read_u1() if self.has_field_collider_name: self.collider_name = AuxTypes.String(self._io, self, self._root) if self.has_field_from_collider_name: self.from_collider_name = AuxTypes.String(self._io, self, self._root) if self.has_field_check_ghost: self.check_ghost = self._io.read_u1() if self.has_field_collider_check_on_init: self.collider_check_on_init = self._io.read_u1() if self.has_field_check_on_reconnect: self.check_on_reconnect = self._io.read_u1() if self.has_field_collider_white_list: self.collider_white_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_collider_black_list: self.collider_black_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_use_level_override: self.use_level_override = self._io.read_u1() if self.has_field_raw_shape: self.raw_shape = Output.DispConfigBaseShape(self._io, self, self._root) if self.has_field_use_local_trigger_logic: self.use_local_trigger_logic = self._io.read_u1() if self.has_field_local_trigger_meta: self.local_trigger_meta = Output.DispConfigLocalTriggerMeta(self._io, self, self._root) @property def has_field_life_time(self): if hasattr(self, '_m_has_field_life_time'): return self._m_has_field_life_time self._m_has_field_life_time = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_life_time', None) @property def has_field_shape(self): if hasattr(self, '_m_has_field_shape'): return self._m_has_field_shape self._m_has_field_shape = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shape', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_check_on_reconnect(self): if hasattr(self, '_m_has_field_check_on_reconnect'): return self._m_has_field_check_on_reconnect self._m_has_field_check_on_reconnect = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_check_on_reconnect', None) @property def has_field_use_level_override(self): if hasattr(self, '_m_has_field_use_level_override'): return self._m_has_field_use_level_override self._m_has_field_use_level_override = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_use_level_override', None) @property def has_field_local_trigger_meta(self): if hasattr(self, '_m_has_field_local_trigger_meta'): return self._m_has_field_local_trigger_meta self._m_has_field_local_trigger_meta = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_local_trigger_meta', None) @property def has_field_use_local_trigger_logic(self): if hasattr(self, '_m_has_field_use_local_trigger_logic'): return self._m_has_field_use_local_trigger_logic self._m_has_field_use_local_trigger_logic = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_use_local_trigger_logic', None) @property def has_field_check_interval(self): if hasattr(self, '_m_has_field_check_interval'): return self._m_has_field_check_interval self._m_has_field_check_interval = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_check_interval', None) @property def has_field_from_eular_offset(self): if hasattr(self, '_m_has_field_from_eular_offset'): return self._m_has_field_from_eular_offset self._m_has_field_from_eular_offset = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_from_eular_offset', None) @property def has_field_check_point(self): if hasattr(self, '_m_has_field_check_point'): return self._m_has_field_check_point self._m_has_field_check_point = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_check_point', None) @property def has_field_trigger_count(self): if hasattr(self, '_m_has_field_trigger_count'): return self._m_has_field_trigger_count self._m_has_field_trigger_count = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_trigger_count', None) @property def has_field_collider_black_list(self): if hasattr(self, '_m_has_field_collider_black_list'): return self._m_has_field_collider_black_list self._m_has_field_collider_black_list = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_collider_black_list', None) @property def has_field_collider_check_on_init(self): if hasattr(self, '_m_has_field_collider_check_on_init'): return self._m_has_field_collider_check_on_init self._m_has_field_collider_check_on_init = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_collider_check_on_init', None) @property def has_field_overwrite_camp_type(self): if hasattr(self, '_m_has_field_overwrite_camp_type'): return self._m_has_field_overwrite_camp_type self._m_has_field_overwrite_camp_type = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_overwrite_camp_type', None) @property def has_field_trigger_flag(self): if hasattr(self, '_m_has_field_trigger_flag'): return self._m_has_field_trigger_flag self._m_has_field_trigger_flag = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_trigger_flag', None) @property def has_field_trigger_infinite(self): if hasattr(self, '_m_has_field_trigger_infinite'): return self._m_has_field_trigger_infinite self._m_has_field_trigger_infinite = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_trigger_infinite', None) @property def has_field_from_collider_name(self): if hasattr(self, '_m_has_field_from_collider_name'): return self._m_has_field_from_collider_name self._m_has_field_from_collider_name = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_from_collider_name', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_trigger_type(self): if hasattr(self, '_m_has_field_trigger_type'): return self._m_has_field_trigger_type self._m_has_field_trigger_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_trigger_type', None) @property def has_field_check_ghost(self): if hasattr(self, '_m_has_field_check_ghost'): return self._m_has_field_check_ghost self._m_has_field_check_ghost = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_check_ghost', None) @property def has_field_check_infinite(self): if hasattr(self, '_m_has_field_check_infinite'): return self._m_has_field_check_infinite self._m_has_field_check_infinite = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_check_infinite', None) @property def has_field_camp_type(self): if hasattr(self, '_m_has_field_camp_type'): return self._m_has_field_camp_type self._m_has_field_camp_type = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_camp_type', None) @property def has_field_from_height(self): if hasattr(self, '_m_has_field_from_height'): return self._m_has_field_from_height self._m_has_field_from_height = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_from_height', None) @property def has_field_check_count(self): if hasattr(self, '_m_has_field_check_count'): return self._m_has_field_check_count self._m_has_field_check_count = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_check_count', None) @property def has_field_from_shape(self): if hasattr(self, '_m_has_field_from_shape'): return self._m_has_field_from_shape self._m_has_field_from_shape = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_from_shape', None) @property def has_field_collider_white_list(self): if hasattr(self, '_m_has_field_collider_white_list'): return self._m_has_field_collider_white_list self._m_has_field_collider_white_list = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_collider_white_list', None) @property def has_field_use_collider(self): if hasattr(self, '_m_has_field_use_collider'): return self._m_has_field_use_collider self._m_has_field_use_collider = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_use_collider', None) @property def has_field_use_surface_height(self): if hasattr(self, '_m_has_field_use_surface_height'): return self._m_has_field_use_surface_height self._m_has_field_use_surface_height = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_use_surface_height', None) @property def has_field_concern_type(self): if hasattr(self, '_m_has_field_concern_type'): return self._m_has_field_concern_type self._m_has_field_concern_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_concern_type', None) @property def has_field_trigger_interval(self): if hasattr(self, '_m_has_field_trigger_interval'): return self._m_has_field_trigger_interval self._m_has_field_trigger_interval = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_trigger_interval', None) @property def has_field_eular_offset(self): if hasattr(self, '_m_has_field_eular_offset'): return self._m_has_field_eular_offset self._m_has_field_eular_offset = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_eular_offset', None) @property def has_field_raw_shape(self): if hasattr(self, '_m_has_field_raw_shape'): return self._m_has_field_raw_shape self._m_has_field_raw_shape = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_raw_shape', None) @property def has_field_life_infinite(self): if hasattr(self, '_m_has_field_life_infinite'): return self._m_has_field_life_infinite self._m_has_field_life_infinite = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_life_infinite', None) @property def has_field_collider_name(self): if hasattr(self, '_m_has_field_collider_name'): return self._m_has_field_collider_name self._m_has_field_collider_name = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_collider_name', None) @property def has_field_from_offset(self): if hasattr(self, '_m_has_field_from_offset'): return self._m_has_field_from_offset self._m_has_field_from_offset = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_from_offset', None) @property def has_field_start_check_time(self): if hasattr(self, '_m_has_field_start_check_time'): return self._m_has_field_start_check_time self._m_has_field_start_check_time = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_start_check_time', None) class GivingTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumIrodoriChessCardNumericalModificationMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardNumericalModificationMode, self.data.value) return getattr(self, '_m_value', None) class ConfigAiReturnToBornPosSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiReturnToBornPosData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiReturnToBornPosData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class DropElemBallTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumVolatileType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VolatileType, self.data.value) return getattr(self, '_m_value', None) class ConfigMainQuestScheme(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_res_id: self.res_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series: self.series = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_main_quest_tag: self.main_quest_tag = Output.EnumMainQuestTagType(self._io, self, self._root) if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lua_path: self.lua_path = AuxTypes.String(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_repeatable: self.repeatable = self._io.read_u1() if self.has_field_suggest_track_main_quest_list: self.suggest_track_main_quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_suggest_track_out_of_order: self.suggest_track_out_of_order = self._io.read_u1() if self.has_field_reward_id_list: self.reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_special_show_reward_id: self.special_show_reward_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_cond_id_list: self.special_show_cond_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_quest_id: self.special_show_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_red_point: self.show_red_point = self._io.read_u1() if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_quests: self.sub_quests = Output.ArrayOfConfigQuestSchemeLengthU(self._io, self, self._root) if self.has_field_talks: self.talks = Output.ArrayOfConfigTalkSchemeLengthU(self._io, self, self._root) if self.has_field_preload_lua_list: self.preload_lua_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_force_preload_lua_list: self.force_preload_lua_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_free_style_dic: self.free_style_dic = Output.DictOfAuxTypesVlqBase128LeUArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_force_preload_lua_list(self): if hasattr(self, '_m_has_field_force_preload_lua_list'): return self._m_has_field_force_preload_lua_list self._m_has_field_force_preload_lua_list = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_force_preload_lua_list', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_show_red_point(self): if hasattr(self, '_m_has_field_show_red_point'): return self._m_has_field_show_red_point self._m_has_field_show_red_point = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_show_red_point', None) @property def has_field_repeatable(self): if hasattr(self, '_m_has_field_repeatable'): return self._m_has_field_repeatable self._m_has_field_repeatable = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_repeatable', None) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_series(self): if hasattr(self, '_m_has_field_series'): return self._m_has_field_series self._m_has_field_series = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_series', None) @property def has_field_free_style_dic(self): if hasattr(self, '_m_has_field_free_style_dic'): return self._m_has_field_free_style_dic self._m_has_field_free_style_dic = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_free_style_dic', None) @property def has_field_reward_id_list(self): if hasattr(self, '_m_has_field_reward_id_list'): return self._m_has_field_reward_id_list self._m_has_field_reward_id_list = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_reward_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_desc', None) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_task_id', None) @property def has_field_talks(self): if hasattr(self, '_m_has_field_talks'): return self._m_has_field_talks self._m_has_field_talks = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_talks', None) @property def has_field_lua_path(self): if hasattr(self, '_m_has_field_lua_path'): return self._m_has_field_lua_path self._m_has_field_lua_path = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_lua_path', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_suggest_track_out_of_order(self): if hasattr(self, '_m_has_field_suggest_track_out_of_order'): return self._m_has_field_suggest_track_out_of_order self._m_has_field_suggest_track_out_of_order = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_suggest_track_out_of_order', None) @property def has_field_special_show_reward_id(self): if hasattr(self, '_m_has_field_special_show_reward_id'): return self._m_has_field_special_show_reward_id self._m_has_field_special_show_reward_id = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_special_show_reward_id', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_active_mode', None) @property def has_field_sub_quests(self): if hasattr(self, '_m_has_field_sub_quests'): return self._m_has_field_sub_quests self._m_has_field_sub_quests = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_sub_quests', None) @property def has_field_special_show_cond_id_list(self): if hasattr(self, '_m_has_field_special_show_cond_id_list'): return self._m_has_field_special_show_cond_id_list self._m_has_field_special_show_cond_id_list = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_special_show_cond_id_list', None) @property def has_field_special_show_quest_id(self): if hasattr(self, '_m_has_field_special_show_quest_id'): return self._m_has_field_special_show_quest_id self._m_has_field_special_show_quest_id = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_special_show_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_show_type', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_res_id(self): if hasattr(self, '_m_has_field_res_id'): return self._m_has_field_res_id self._m_has_field_res_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_res_id', None) @property def has_field_suggest_track_main_quest_list(self): if hasattr(self, '_m_has_field_suggest_track_main_quest_list'): return self._m_has_field_suggest_track_main_quest_list self._m_has_field_suggest_track_main_quest_list = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_suggest_track_main_quest_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_activity_id', None) @property def has_field_preload_lua_list(self): if hasattr(self, '_m_has_field_preload_lua_list'): return self._m_has_field_preload_lua_list self._m_has_field_preload_lua_list = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_preload_lua_list', None) @property def has_field_main_quest_tag(self): if hasattr(self, '_m_has_field_main_quest_tag'): return self._m_has_field_main_quest_tag self._m_has_field_main_quest_tag = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_main_quest_tag', None) class ServerLuaTriggerEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lua_call_type: self.lua_call_type = Output.EnumLuaCallType(self._io, self, self._root) if self.has_field_is_target: self.is_target = self._io.read_u1() if self.has_field_call_param_list: self.call_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_source_name: self.source_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param_num: self.param_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_call_param_list(self): if hasattr(self, '_m_has_field_call_param_list'): return self._m_has_field_call_param_list self._m_has_field_call_param_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_call_param_list', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_param3', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_target(self): if hasattr(self, '_m_has_field_is_target'): return self._m_has_field_is_target self._m_has_field_is_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_target', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_source_name(self): if hasattr(self, '_m_has_field_source_name'): return self._m_has_field_source_name self._m_has_field_source_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_source_name', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_param2', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_param1', None) @property def has_field_lua_call_type(self): if hasattr(self, '_m_has_field_lua_call_type'): return self._m_has_field_lua_call_type self._m_has_field_lua_call_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lua_call_type', None) @property def has_field_param_num(self): if hasattr(self, '_m_has_field_param_num'): return self._m_has_field_param_num self._m_has_field_param_num = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_param_num', None) class ConfigGuideAvatarChangeCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ByTargetHpValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hp: self.hp = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_hp(self): if hasattr(self, '_m_has_field_hp'): return self._m_has_field_hp self._m_has_field_hp = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hp', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class BonusActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPinballBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_trace_on_y_axis: self.trace_on_y_axis = self._io.read_u1() if self.has_field_destroy_when_target_die: self.destroy_when_target_die = self._io.read_u1() if self.has_field_random_back_angle_added: self.random_back_angle_added = self._io.read_f4le() if self.has_field_rebound_interval: self.rebound_interval = self._io.read_f4le() if self.has_field_out_of_range_fix_cd: self.out_of_range_fix_cd = self._io.read_f4le() @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def has_field_random_back_angle_added(self): if hasattr(self, '_m_has_field_random_back_angle_added'): return self._m_has_field_random_back_angle_added self._m_has_field_random_back_angle_added = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_back_angle_added', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def has_field_destroy_when_target_die(self): if hasattr(self, '_m_has_field_destroy_when_target_die'): return self._m_has_field_destroy_when_target_die self._m_has_field_destroy_when_target_die = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_destroy_when_target_die', None) @property def has_field_out_of_range_fix_cd(self): if hasattr(self, '_m_has_field_out_of_range_fix_cd'): return self._m_has_field_out_of_range_fix_cd self._m_has_field_out_of_range_fix_cd = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_out_of_range_fix_cd', None) @property def has_field_rebound_interval(self): if hasattr(self, '_m_has_field_rebound_interval'): return self._m_has_field_rebound_interval self._m_has_field_rebound_interval = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_rebound_interval', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def has_field_trace_on_y_axis(self): if hasattr(self, '_m_has_field_trace_on_y_axis'): return self._m_has_field_trace_on_y_axis self._m_has_field_trace_on_y_axis = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trace_on_y_axis', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class MapTagDataConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumMapTagType(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name_with_ruby_text: self.name_with_ruby_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_unlock_by_default: self.unlock_by_default = self._io.read_u1() if self.has_field_hide_before_unlock: self.hide_before_unlock = self._io.read_u1() if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trans_point_id: self.trans_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id_list: self.scene_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_default_locate_x: self.default_locate_x = self._io.read_f4le() if self.has_field_default_locate_z: self.default_locate_z = self._io.read_f4le() @property def has_field_default_locate_z(self): if hasattr(self, '_m_has_field_default_locate_z'): return self._m_has_field_default_locate_z self._m_has_field_default_locate_z = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_default_locate_z', None) @property def has_field_default_locate_x(self): if hasattr(self, '_m_has_field_default_locate_x'): return self._m_has_field_default_locate_x self._m_has_field_default_locate_x = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_default_locate_x', None) @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sort_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_scene_id_list(self): if hasattr(self, '_m_has_field_scene_id_list'): return self._m_has_field_scene_id_list self._m_has_field_scene_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_scene_id_list', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_unlock_by_default(self): if hasattr(self, '_m_has_field_unlock_by_default'): return self._m_has_field_unlock_by_default self._m_has_field_unlock_by_default = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_by_default', None) @property def has_field_trans_point_id(self): if hasattr(self, '_m_has_field_trans_point_id'): return self._m_has_field_trans_point_id self._m_has_field_trans_point_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_trans_point_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hide_before_unlock(self): if hasattr(self, '_m_has_field_hide_before_unlock'): return self._m_has_field_hide_before_unlock self._m_has_field_hide_before_unlock = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_hide_before_unlock', None) @property def has_field_name_with_ruby_text(self): if hasattr(self, '_m_has_field_name_with_ruby_text'): return self._m_has_field_name_with_ruby_text self._m_has_field_name_with_ruby_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_name_with_ruby_text', None) class ArrayOfConfigRouteLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRoute(self._io, self, self._root)) class TowerScheduleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RecipeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeErosionAreaExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClearLocalGadgets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigDynamicTalentLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigDynamicTalent(self._io, self, self._root)) class ConfigEffectPoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_preinstantiate_num_when_preload: self.preinstantiate_num_when_preload = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_used_size: self.max_used_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_preinstantiate_num_when_preload(self): if hasattr(self, '_m_has_field_preinstantiate_num_when_preload'): return self._m_has_field_preinstantiate_num_when_preload self._m_has_field_preinstantiate_num_when_preload = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_preinstantiate_num_when_preload', None) @property def has_field_max_used_size(self): if hasattr(self, '_m_has_field_max_used_size'): return self._m_has_field_max_used_size self._m_has_field_max_used_size = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_used_size', None) class ActivityCrystalLinkEffectBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_title: self.ability_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_desc: self.ability_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_pre = self._io.read_s1() if self.has_field_des_param: self.des_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ability_desc(self): if hasattr(self, '_m_has_field_ability_desc'): return self._m_has_field_ability_desc self._m_has_field_ability_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_ability_desc', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_ability_title(self): if hasattr(self, '_m_has_field_ability_title'): return self._m_has_field_ability_title self._m_has_field_ability_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_ability_title', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_buff_id', None) @property def has_field_icon_name_hash(self): if hasattr(self, '_m_has_field_icon_name_hash'): return self._m_has_field_icon_name_hash self._m_has_field_icon_name_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon_name_hash', None) @property def has_field_des_param(self): if hasattr(self, '_m_has_field_des_param'): return self._m_has_field_des_param self._m_has_field_des_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_des_param', None) class CookBonusExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCreateSeverGadgetOpType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CreateSeverGadgetOpType, self.data.value) return getattr(self, '_m_value', None) class EnumVoicePersonality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VoicePersonality, self.data.value) return getattr(self, '_m_value', None) class SectrPlatformStreamLayerRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNormalStateLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseStateLayer(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_state_i_ds: self.state_i_ds = Output.DictOfAuxTypesStringDispConfigBaseStateIdInfo(self._io, self, self._root) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_i_ds', None) @property def layer_index(self): if hasattr(self, '_m_layer_index'): return self._m_layer_index self._m_layer_index = self.base.layer_index return getattr(self, '_m_layer_index', None) @property def layer_index_name(self): if hasattr(self, '_m_layer_index_name'): return self._m_layer_index_name self._m_layer_index_name = self.base.layer_index_name return getattr(self, '_m_layer_index_name', None) class ArrayOfConfigRandomTalkSchemeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRandomTalkScheme(self._io, self, self._root)) class ConfigGlobalAi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_melee_slot_radius: self.avatar_melee_slot_radius = self._io.read_f4le() if self.has_field_avoidance_radius: self.avoidance_radius = self._io.read_f4le() if self.has_field_avoidance_force: self.avoidance_force = self._io.read_f4le() if self.has_field_lod0: self.lod0 = self._io.read_f4le() if self.has_field_lod1: self.lod1 = self._io.read_f4le() if self.has_field_lod2: self.lod2 = self._io.read_f4le() if self.has_field_sensing_ignore_camp_i_ds: self.sensing_ignore_camp_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_public_c_ds: self.public_c_ds = Output.DictOfAuxTypesStringConfigPublicAiSkillCd(self._io, self, self._root) if self.has_field_default_weather_neuron_mapping: self.default_weather_neuron_mapping = Output.DictOfEnumConfigWeatherTypeArrayOfEnumNeuronNameLengthU(self._io, self, self._root) if self.has_field_use_server_pathfinding: self.use_server_pathfinding = self._io.read_u1() @property def has_field_lod0(self): if hasattr(self, '_m_has_field_lod0'): return self._m_has_field_lod0 self._m_has_field_lod0 = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_lod0', None) @property def has_field_avatar_melee_slot_radius(self): if hasattr(self, '_m_has_field_avatar_melee_slot_radius'): return self._m_has_field_avatar_melee_slot_radius self._m_has_field_avatar_melee_slot_radius = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_avatar_melee_slot_radius', None) @property def has_field_use_server_pathfinding(self): if hasattr(self, '_m_has_field_use_server_pathfinding'): return self._m_has_field_use_server_pathfinding self._m_has_field_use_server_pathfinding = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_use_server_pathfinding', None) @property def has_field_avoidance_radius(self): if hasattr(self, '_m_has_field_avoidance_radius'): return self._m_has_field_avoidance_radius self._m_has_field_avoidance_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_avoidance_radius', None) @property def has_field_default_weather_neuron_mapping(self): if hasattr(self, '_m_has_field_default_weather_neuron_mapping'): return self._m_has_field_default_weather_neuron_mapping self._m_has_field_default_weather_neuron_mapping = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_default_weather_neuron_mapping', None) @property def has_field_lod1(self): if hasattr(self, '_m_has_field_lod1'): return self._m_has_field_lod1 self._m_has_field_lod1 = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_lod1', None) @property def has_field_avoidance_force(self): if hasattr(self, '_m_has_field_avoidance_force'): return self._m_has_field_avoidance_force self._m_has_field_avoidance_force = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_avoidance_force', None) @property def has_field_public_c_ds(self): if hasattr(self, '_m_has_field_public_c_ds'): return self._m_has_field_public_c_ds self._m_has_field_public_c_ds = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_public_c_ds', None) @property def has_field_lod2(self): if hasattr(self, '_m_has_field_lod2'): return self._m_has_field_lod2 self._m_has_field_lod2 = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_lod2', None) @property def has_field_sensing_ignore_camp_i_ds(self): if hasattr(self, '_m_has_field_sensing_ignore_camp_i_ds'): return self._m_has_field_sensing_ignore_camp_i_ds self._m_has_field_sensing_ignore_camp_i_ds = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_sensing_ignore_camp_i_ds', None) class AttachModifierToElementDurabilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigAudioArea2dInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_leave_reverb_delay: self.leave_reverb_delay = self._io.read_f4le() if self.has_field_enter_reverb_states: self.enter_reverb_states = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) if self.has_field_leave_reverb_states: self.leave_reverb_states = Output.ArrayOfAudioStateOpLengthU(self._io, self, self._root) @property def has_field_leave_reverb_delay(self): if hasattr(self, '_m_has_field_leave_reverb_delay'): return self._m_has_field_leave_reverb_delay self._m_has_field_leave_reverb_delay = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_leave_reverb_delay', None) @property def has_field_enter_reverb_states(self): if hasattr(self, '_m_has_field_enter_reverb_states'): return self._m_has_field_enter_reverb_states self._m_has_field_enter_reverb_states = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enter_reverb_states', None) @property def has_field_leave_reverb_states(self): if hasattr(self, '_m_has_field_leave_reverb_states'): return self._m_has_field_leave_reverb_states self._m_has_field_leave_reverb_states = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_leave_reverb_states', None) class ArrayOfConfigCodexQuestSubQuestLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCodexQuestSubQuest(self._io, self, self._root)) class DraftTransferConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_config_id', None) class EnumConfigScheduleJobType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigScheduleJobType, self.data.value) return getattr(self, '_m_value', None) class TowerRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_group: self.reward_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_floor: self.floor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id3stars: self.reward_id3stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id6stars: self.reward_id6stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id9stars: self.reward_id9stars = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id_room: self.reward_id_room = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_reward_id6stars(self): if hasattr(self, '_m_has_field_reward_id6stars'): return self._m_has_field_reward_id6stars self._m_has_field_reward_id6stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id6stars', None) @property def has_field_reward_id3stars(self): if hasattr(self, '_m_has_field_reward_id3stars'): return self._m_has_field_reward_id3stars self._m_has_field_reward_id3stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id3stars', None) @property def has_field_reward_group(self): if hasattr(self, '_m_has_field_reward_group'): return self._m_has_field_reward_group self._m_has_field_reward_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_group', None) @property def has_field_reward_id_room(self): if hasattr(self, '_m_has_field_reward_id_room'): return self._m_has_field_reward_id_room self._m_has_field_reward_id_room = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id_room', None) @property def has_field_reward_id9stars(self): if hasattr(self, '_m_has_field_reward_id9stars'): return self._m_has_field_reward_id9stars self._m_has_field_reward_id9stars = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id9stars', None) @property def has_field_floor(self): if hasattr(self, '_m_has_field_floor'): return self._m_has_field_floor self._m_has_field_floor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_floor', None) class EnumActionTokenType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionTokenType, self.data.value) return getattr(self, '_m_value', None) class LunaRiteQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_type: self.quest_type = Output.EnumLunaRiteQuestType(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_atmosphere_need: self.atmosphere_need = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_icon: self.chapter_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_chapter: self.chapter = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_chapter(self): if hasattr(self, '_m_has_field_chapter'): return self._m_has_field_chapter self._m_has_field_chapter = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_chapter', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_quest_type(self): if hasattr(self, '_m_has_field_quest_type'): return self._m_has_field_quest_type self._m_has_field_quest_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quest_type', None) @property def has_field_atmosphere_need(self): if hasattr(self, '_m_has_field_atmosphere_need'): return self._m_has_field_atmosphere_need self._m_has_field_atmosphere_need = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_atmosphere_need', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_chapter_icon(self): if hasattr(self, '_m_has_field_chapter_icon'): return self._m_has_field_chapter_icon self._m_has_field_chapter_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_chapter_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class DictOfAuxTypesVlqBase128LeUVoiceTriggerIdentity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUVoiceTriggerIdentity(self._io, self, self._root)) class ConfigBaseInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumInteractionType(self._io, self, self._root) if self.has_field_delay_time: self.delay_time = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_alias_list: self.alias_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_check_next_immediately: self.check_next_immediately = self._io.read_u1() if self.has_field_action_id: self.action_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_action_id: self.pre_action_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_have_next_action: self.have_next_action = self._io.read_u1() @property def has_field_have_next_action(self): if hasattr(self, '_m_has_field_have_next_action'): return self._m_has_field_have_next_action self._m_has_field_have_next_action = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_have_next_action', None) @property def has_field_delay_time(self): if hasattr(self, '_m_has_field_delay_time'): return self._m_has_field_delay_time self._m_has_field_delay_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_delay_time', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_action_id(self): if hasattr(self, '_m_has_field_action_id'): return self._m_has_field_action_id self._m_has_field_action_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_action_id', None) @property def has_field_alias_list(self): if hasattr(self, '_m_has_field_alias_list'): return self._m_has_field_alias_list self._m_has_field_alias_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_alias_list', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_check_next_immediately(self): if hasattr(self, '_m_has_field_check_next_immediately'): return self._m_has_field_check_next_immediately self._m_has_field_check_next_immediately = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_check_next_immediately', None) @property def has_field_pre_action_id(self): if hasattr(self, '_m_has_field_pre_action_id'): return self._m_has_field_pre_action_id self._m_has_field_pre_action_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_pre_action_id', None) class FetterStoryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_is_hiden: self.is_hiden = self._io.read_u1() if self.has_field_story_title: self.story_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_context: self.story_context = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_title2: self.story_title2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_context2: self.story_context2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tips: self.tips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_story_title_locked: self.story_title_locked = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) @property def has_field_story_title(self): if hasattr(self, '_m_has_field_story_title'): return self._m_has_field_story_title self._m_has_field_story_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_story_title', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_story_title2(self): if hasattr(self, '_m_has_field_story_title2'): return self._m_has_field_story_title2 self._m_has_field_story_title2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_story_title2', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_tips(self): if hasattr(self, '_m_has_field_tips'): return self._m_has_field_tips self._m_has_field_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tips', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_finish_conds', None) @property def has_field_story_context(self): if hasattr(self, '_m_has_field_story_context'): return self._m_has_field_story_context self._m_has_field_story_context = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_story_context', None) @property def has_field_story_title_locked(self): if hasattr(self, '_m_has_field_story_title_locked'): return self._m_has_field_story_title_locked self._m_has_field_story_title_locked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_story_title_locked', None) @property def has_field_story_context2(self): if hasattr(self, '_m_has_field_story_context2'): return self._m_has_field_story_context2 self._m_has_field_story_context2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_story_context2', None) @property def has_field_is_hiden(self): if hasattr(self, '_m_has_field_is_hiden'): return self._m_has_field_is_hiden self._m_has_field_is_hiden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_is_hiden', None) class ArrayOfLayeredSamplingDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.LayeredSamplingData(self._io, self, self._root)) class FleurFairDungeonStatTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EchoShellPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_voice_id: self.special_voice_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_voice_unlock_cond_id: self.special_voice_unlock_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_voice_lock_tip: self.special_voice_lock_tip = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_beta_blocked: self.is_beta_blocked = self._io.read_u1() @property def has_field_special_voice_id(self): if hasattr(self, '_m_has_field_special_voice_id'): return self._m_has_field_special_voice_id self._m_has_field_special_voice_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_special_voice_id', None) @property def has_field_special_voice_unlock_cond_id(self): if hasattr(self, '_m_has_field_special_voice_unlock_cond_id'): return self._m_has_field_special_voice_unlock_cond_id self._m_has_field_special_voice_unlock_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_special_voice_unlock_cond_id', None) @property def has_field_special_voice_lock_tip(self): if hasattr(self, '_m_has_field_special_voice_lock_tip'): return self._m_has_field_special_voice_lock_tip self._m_has_field_special_voice_lock_tip = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_special_voice_lock_tip', None) @property def has_field_is_beta_blocked(self): if hasattr(self, '_m_has_field_is_beta_blocked'): return self._m_has_field_is_beta_blocked self._m_has_field_is_beta_blocked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_beta_blocked', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class BattlePassRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LunaRiteBattleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_type: self.region_type = Output.EnumLunaRiteRegionType(self._io, self, self._root) if self.has_field_consecrate_id: self.consecrate_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_bundle_id: self.group_bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_icon: self.challenge_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_monster_info: self.monster_info = AuxTypes.String(self._io, self, self._root) if self.has_field_elite_monster_info: self.elite_monster_info = AuxTypes.String(self._io, self, self._root) if self.has_field_ruler: self.ruler = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recipe_source: self.recipe_source = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_group_bundle_id(self): if hasattr(self, '_m_has_field_group_bundle_id'): return self._m_has_field_group_bundle_id self._m_has_field_group_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_bundle_id', None) @property def has_field_challenge_icon(self): if hasattr(self, '_m_has_field_challenge_icon'): return self._m_has_field_challenge_icon self._m_has_field_challenge_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_challenge_icon', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_consecrate_id(self): if hasattr(self, '_m_has_field_consecrate_id'): return self._m_has_field_consecrate_id self._m_has_field_consecrate_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_consecrate_id', None) @property def has_field_elite_monster_info(self): if hasattr(self, '_m_has_field_elite_monster_info'): return self._m_has_field_elite_monster_info self._m_has_field_elite_monster_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_elite_monster_info', None) @property def has_field_monster_info(self): if hasattr(self, '_m_has_field_monster_info'): return self._m_has_field_monster_info self._m_has_field_monster_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_monster_info', None) @property def has_field_recipe_source(self): if hasattr(self, '_m_has_field_recipe_source'): return self._m_has_field_recipe_source self._m_has_field_recipe_source = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_recipe_source', None) @property def has_field_region_type(self): if hasattr(self, '_m_has_field_region_type'): return self._m_has_field_region_type self._m_has_field_region_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_region_type', None) @property def has_field_ruler(self): if hasattr(self, '_m_has_field_ruler'): return self._m_has_field_ruler self._m_has_field_ruler = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_ruler', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class QteStepButtonStyleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPredicateByTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_night: self.is_night = self._io.read_u1() @property def has_field_is_night(self): if hasattr(self, '_m_has_field_is_night'): return self._m_has_field_is_night self._m_has_field_is_night = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_night', None) class ConfigUiGlobal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_input_actions: self.input_actions = Output.DictOfEnumInputActionTypeDispConfigBaseInputAction(self._io, self, self._root) if self.has_field_input_events: self.input_events = Output.DictOfEnumInputEventTypeConfigBaseInputEvent(self._io, self, self._root) if self.has_field_action_groups: self.action_groups = Output.DictOfAuxTypesStringArrayOfInputActionEventLengthU(self._io, self, self._root) if self.has_field_input_modes: self.input_modes = Output.DictOfAuxTypesStringConfigBaseContext(self._io, self, self._root) if self.has_field_joypad_change_view_scale: self.joypad_change_view_scale = Output.Point2d(self._io, self, self._root) if self.has_field_joypad_long_press_duration: self.joypad_long_press_duration = self._io.read_f4le() if self.has_field_joypad_sense_scales: self.joypad_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_joypad_focus_sense_scales: self.joypad_focus_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_mouse_sense_scales: self.mouse_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_mouse_focus_sense_scales: self.mouse_focus_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_touchpad_sense_scales: self.touchpad_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_touchpad_focus_sense_scales: self.touchpad_focus_sense_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_touchpad_focus_acceleration_scales: self.touchpad_focus_acceleration_scales = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_touchpad_focus_acceleration_para: self.touchpad_focus_acceleration_para = Output.TouchpadFocusAccelerationSigmoidPara(self._io, self, self._root) if self.has_field_config_ui_photograph: self.config_ui_photograph = Output.ConfigUiPhotograph(self._io, self, self._root) if self.has_field_config_input_check: self.config_input_check = Output.ConfigInputCheck(self._io, self, self._root) @property def has_field_config_input_check(self): if hasattr(self, '_m_has_field_config_input_check'): return self._m_has_field_config_input_check self._m_has_field_config_input_check = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_config_input_check', None) @property def has_field_mouse_sense_scales(self): if hasattr(self, '_m_has_field_mouse_sense_scales'): return self._m_has_field_mouse_sense_scales self._m_has_field_mouse_sense_scales = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_mouse_sense_scales', None) @property def has_field_touchpad_focus_acceleration_para(self): if hasattr(self, '_m_has_field_touchpad_focus_acceleration_para'): return self._m_has_field_touchpad_focus_acceleration_para self._m_has_field_touchpad_focus_acceleration_para = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_touchpad_focus_acceleration_para', None) @property def has_field_joypad_long_press_duration(self): if hasattr(self, '_m_has_field_joypad_long_press_duration'): return self._m_has_field_joypad_long_press_duration self._m_has_field_joypad_long_press_duration = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_joypad_long_press_duration', None) @property def has_field_action_groups(self): if hasattr(self, '_m_has_field_action_groups'): return self._m_has_field_action_groups self._m_has_field_action_groups = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_action_groups', None) @property def has_field_input_modes(self): if hasattr(self, '_m_has_field_input_modes'): return self._m_has_field_input_modes self._m_has_field_input_modes = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_input_modes', None) @property def has_field_touchpad_focus_acceleration_scales(self): if hasattr(self, '_m_has_field_touchpad_focus_acceleration_scales'): return self._m_has_field_touchpad_focus_acceleration_scales self._m_has_field_touchpad_focus_acceleration_scales = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_touchpad_focus_acceleration_scales', None) @property def has_field_input_actions(self): if hasattr(self, '_m_has_field_input_actions'): return self._m_has_field_input_actions self._m_has_field_input_actions = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_input_actions', None) @property def has_field_joypad_change_view_scale(self): if hasattr(self, '_m_has_field_joypad_change_view_scale'): return self._m_has_field_joypad_change_view_scale self._m_has_field_joypad_change_view_scale = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_joypad_change_view_scale', None) @property def has_field_config_ui_photograph(self): if hasattr(self, '_m_has_field_config_ui_photograph'): return self._m_has_field_config_ui_photograph self._m_has_field_config_ui_photograph = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_config_ui_photograph', None) @property def has_field_mouse_focus_sense_scales(self): if hasattr(self, '_m_has_field_mouse_focus_sense_scales'): return self._m_has_field_mouse_focus_sense_scales self._m_has_field_mouse_focus_sense_scales = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_mouse_focus_sense_scales', None) @property def has_field_touchpad_focus_sense_scales(self): if hasattr(self, '_m_has_field_touchpad_focus_sense_scales'): return self._m_has_field_touchpad_focus_sense_scales self._m_has_field_touchpad_focus_sense_scales = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_touchpad_focus_sense_scales', None) @property def has_field_joypad_focus_sense_scales(self): if hasattr(self, '_m_has_field_joypad_focus_sense_scales'): return self._m_has_field_joypad_focus_sense_scales self._m_has_field_joypad_focus_sense_scales = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_joypad_focus_sense_scales', None) @property def has_field_touchpad_sense_scales(self): if hasattr(self, '_m_has_field_touchpad_sense_scales'): return self._m_has_field_touchpad_sense_scales self._m_has_field_touchpad_sense_scales = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_touchpad_sense_scales', None) @property def has_field_input_events(self): if hasattr(self, '_m_has_field_input_events'): return self._m_has_field_input_events self._m_has_field_input_events = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_input_events', None) @property def has_field_joypad_sense_scales(self): if hasattr(self, '_m_has_field_joypad_sense_scales'): return self._m_has_field_joypad_sense_scales self._m_has_field_joypad_sense_scales = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_joypad_sense_scales', None) class EnumTutorialDetailType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TutorialDetailType, self.data.value) return getattr(self, '_m_value', None) class SelectTargetsByShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shape_name: self.shape_name = AuxTypes.String(self._io, self, self._root) if self.has_field_center_based_on: self.center_based_on = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_camp_based_on: self.camp_based_on = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_size_ratio: self.size_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_camp_based_on(self): if hasattr(self, '_m_has_field_camp_based_on'): return self._m_has_field_camp_based_on self._m_has_field_camp_based_on = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_camp_based_on', None) @property def has_field_size_ratio(self): if hasattr(self, '_m_has_field_size_ratio'): return self._m_has_field_size_ratio self._m_has_field_size_ratio = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_size_ratio', None) @property def has_field_shape_name(self): if hasattr(self, '_m_has_field_shape_name'): return self._m_has_field_shape_name self._m_has_field_shape_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shape_name', None) @property def has_field_center_based_on(self): if hasattr(self, '_m_has_field_center_based_on'): return self._m_has_field_center_based_on self._m_has_field_center_based_on = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_center_based_on', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) class EnumAiLodStrategyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AiLodStrategyType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictEnumVolatileTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumVolatileType(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class SourceJumpTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPerfRatingCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfRatingCategory, self.data.value) return getattr(self, '_m_value', None) class GadgetUpgradeChainMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class SceneExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicGameBasicConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_music_id: self.music_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_music_level: self.music_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_path: self.json_path = AuxTypes.String(self._io, self, self._root) if self.has_field_long_press_interval: self.long_press_interval = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_long_press_down_speed: self.long_press_down_speed = self._io.read_f4le() if self.has_field_long_press_pre_time: self.long_press_pre_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_pre_point: self.success_pre_point = self._io.read_f4le() if self.has_field_success_late_point: self.success_late_point = self._io.read_f4le() if self.has_field_scale_time: self.scale_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_late_drop_time: self.late_drop_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scale_range: self.scale_range = self._io.read_f4le() if self.has_field_score_level_list: self.score_level_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_score_one_key: self.score_one_key = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_great: self.score_great = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_long_press: self.score_long_press = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bpm: self.bpm = self._io.read_f4le() if self.has_field_bpm_dict: self.bpm_dict = Output.DictOfAuxTypesVlqBase128LeUF4(self._io, self, self._root) if self.has_field_ugc_beat_division_options: self.ugc_beat_division_options = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ugc_default_beat_division: self.ugc_default_beat_division = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_simple_hint_json_path: self.simple_hint_json_path = AuxTypes.String(self._io, self, self._root) if self.has_field_complex_hint_json_path: self.complex_hint_json_path = AuxTypes.String(self._io, self, self._root) if self.has_field_note_count: self.note_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_combo_config: self.combo_config = Output.ArrayOfComboConfigLengthS(self._io, self, self._root) if self.has_field_unlock_tips: self.unlock_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_solo_config: self.solo_config = Output.ArrayOfSoloConfigLengthS(self._io, self, self._root) @property def has_field_scale_time(self): if hasattr(self, '_m_has_field_scale_time'): return self._m_has_field_scale_time self._m_has_field_scale_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_scale_time', None) @property def has_field_ugc_default_beat_division(self): if hasattr(self, '_m_has_field_ugc_default_beat_division'): return self._m_has_field_ugc_default_beat_division self._m_has_field_ugc_default_beat_division = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_ugc_default_beat_division', None) @property def has_field_long_press_down_speed(self): if hasattr(self, '_m_has_field_long_press_down_speed'): return self._m_has_field_long_press_down_speed self._m_has_field_long_press_down_speed = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_long_press_down_speed', None) @property def has_field_scale_range(self): if hasattr(self, '_m_has_field_scale_range'): return self._m_has_field_scale_range self._m_has_field_scale_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_scale_range', None) @property def has_field_long_press_interval(self): if hasattr(self, '_m_has_field_long_press_interval'): return self._m_has_field_long_press_interval self._m_has_field_long_press_interval = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_long_press_interval', None) @property def has_field_note_count(self): if hasattr(self, '_m_has_field_note_count'): return self._m_has_field_note_count self._m_has_field_note_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_note_count', None) @property def has_field_score_long_press(self): if hasattr(self, '_m_has_field_score_long_press'): return self._m_has_field_score_long_press self._m_has_field_score_long_press = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_score_long_press', None) @property def has_field_success_late_point(self): if hasattr(self, '_m_has_field_success_late_point'): return self._m_has_field_success_late_point self._m_has_field_success_late_point = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_success_late_point', None) @property def has_field_score_one_key(self): if hasattr(self, '_m_has_field_score_one_key'): return self._m_has_field_score_one_key self._m_has_field_score_one_key = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_score_one_key', None) @property def has_field_simple_hint_json_path(self): if hasattr(self, '_m_has_field_simple_hint_json_path'): return self._m_has_field_simple_hint_json_path self._m_has_field_simple_hint_json_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_simple_hint_json_path', None) @property def has_field_complex_hint_json_path(self): if hasattr(self, '_m_has_field_complex_hint_json_path'): return self._m_has_field_complex_hint_json_path self._m_has_field_complex_hint_json_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_complex_hint_json_path', None) @property def has_field_late_drop_time(self): if hasattr(self, '_m_has_field_late_drop_time'): return self._m_has_field_late_drop_time self._m_has_field_late_drop_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_late_drop_time', None) @property def has_field_ugc_beat_division_options(self): if hasattr(self, '_m_has_field_ugc_beat_division_options'): return self._m_has_field_ugc_beat_division_options self._m_has_field_ugc_beat_division_options = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_ugc_beat_division_options', None) @property def has_field_music_level(self): if hasattr(self, '_m_has_field_music_level'): return self._m_has_field_music_level self._m_has_field_music_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_music_level', None) @property def has_field_bpm(self): if hasattr(self, '_m_has_field_bpm'): return self._m_has_field_bpm self._m_has_field_bpm = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_bpm', None) @property def has_field_score_great(self): if hasattr(self, '_m_has_field_score_great'): return self._m_has_field_score_great self._m_has_field_score_great = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_score_great', None) @property def has_field_bpm_dict(self): if hasattr(self, '_m_has_field_bpm_dict'): return self._m_has_field_bpm_dict self._m_has_field_bpm_dict = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_bpm_dict', None) @property def has_field_combo_config(self): if hasattr(self, '_m_has_field_combo_config'): return self._m_has_field_combo_config self._m_has_field_combo_config = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_combo_config', None) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_json_path', None) @property def has_field_success_pre_point(self): if hasattr(self, '_m_has_field_success_pre_point'): return self._m_has_field_success_pre_point self._m_has_field_success_pre_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_success_pre_point', None) @property def has_field_score_level_list(self): if hasattr(self, '_m_has_field_score_level_list'): return self._m_has_field_score_level_list self._m_has_field_score_level_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_score_level_list', None) @property def has_field_long_press_pre_time(self): if hasattr(self, '_m_has_field_long_press_pre_time'): return self._m_has_field_long_press_pre_time self._m_has_field_long_press_pre_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_long_press_pre_time', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_music_id(self): if hasattr(self, '_m_has_field_music_id'): return self._m_has_field_music_id self._m_has_field_music_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_music_id', None) @property def has_field_unlock_tips(self): if hasattr(self, '_m_has_field_unlock_tips'): return self._m_has_field_unlock_tips self._m_has_field_unlock_tips = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_unlock_tips', None) @property def has_field_solo_config(self): if hasattr(self, '_m_has_field_solo_config'): return self._m_has_field_solo_config self._m_has_field_solo_config = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_solo_config', None) class EnumPinType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PinType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigEntityColliderLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEntityCollider(self._io, self, self._root)) class ConfigVideo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hero_diff: self.hero_diff = self._io.read_u1() if self.has_field_video_name: self.video_name = AuxTypes.String(self._io, self, self._root) if self.has_field_video_name_other: self.video_name_other = AuxTypes.String(self._io, self, self._root) if self.has_field_subtitle_id: self.subtitle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_subtitle_id_other: self.subtitle_id_other = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_can_skip: self.can_skip = self._io.read_u1() if self.has_field_bg_color: self.bg_color = Output.ColorVector(self._io, self, self._root) if self.has_field_fade_in_duration: self.fade_in_duration = self._io.read_f4le() if self.has_field_fade_out_duration: self.fade_out_duration = self._io.read_f4le() if self.has_field_video_screen_adaptation: self.video_screen_adaptation = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bg_color(self): if hasattr(self, '_m_has_field_bg_color'): return self._m_has_field_bg_color self._m_has_field_bg_color = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_bg_color', None) @property def has_field_can_skip(self): if hasattr(self, '_m_has_field_can_skip'): return self._m_has_field_can_skip self._m_has_field_can_skip = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_can_skip', None) @property def has_field_subtitle_id(self): if hasattr(self, '_m_has_field_subtitle_id'): return self._m_has_field_subtitle_id self._m_has_field_subtitle_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_subtitle_id', None) @property def has_field_video_name_other(self): if hasattr(self, '_m_has_field_video_name_other'): return self._m_has_field_video_name_other self._m_has_field_video_name_other = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_video_name_other', None) @property def has_field_video_screen_adaptation(self): if hasattr(self, '_m_has_field_video_screen_adaptation'): return self._m_has_field_video_screen_adaptation self._m_has_field_video_screen_adaptation = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_video_screen_adaptation', None) @property def has_field_fade_in_duration(self): if hasattr(self, '_m_has_field_fade_in_duration'): return self._m_has_field_fade_in_duration self._m_has_field_fade_in_duration = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_fade_in_duration', None) @property def has_field_fade_out_duration(self): if hasattr(self, '_m_has_field_fade_out_duration'): return self._m_has_field_fade_out_duration self._m_has_field_fade_out_duration = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_fade_out_duration', None) @property def has_field_subtitle_id_other(self): if hasattr(self, '_m_has_field_subtitle_id_other'): return self._m_has_field_subtitle_id_other self._m_has_field_subtitle_id_other = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_subtitle_id_other', None) @property def has_field_hero_diff(self): if hasattr(self, '_m_has_field_hero_diff'): return self._m_has_field_hero_diff self._m_has_field_hero_diff = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_hero_diff', None) @property def has_field_video_name(self): if hasattr(self, '_m_has_field_video_name'): return self._m_has_field_video_name self._m_has_field_video_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_video_name', None) class EnumLevelOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LevelOption, self.data.value) return getattr(self, '_m_value', None) class ConfigMapGlobal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mini_map_ui_radius: self.mini_map_ui_radius = self._io.read_f4le() if self.has_field_mini_map_sight_radius: self.mini_map_sight_radius = self._io.read_f4le() if self.has_field_mini_map_scale_default: self.mini_map_scale_default = self._io.read_f4le() if self.has_field_mini_map_scale_ranks: self.mini_map_scale_ranks = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_level_map_scale_default: self.level_map_scale_default = self._io.read_f4le() if self.has_field_level_map_scale_max: self.level_map_scale_max = self._io.read_f4le() if self.has_field_level_map_scale_min: self.level_map_scale_min = self._io.read_f4le() if self.has_field_level_map_trans_point_radius: self.level_map_trans_point_radius = self._io.read_f4le() if self.has_field_level_map_custom_mark_cancel_radius: self.level_map_custom_mark_cancel_radius = self._io.read_f4le() if self.has_field_level_map_custom_mark_near_cancel_radius: self.level_map_custom_mark_near_cancel_radius = self._io.read_f4le() if self.has_field_custom_styles: self.custom_styles = Output.ArrayOfConfigVCustomMapMarkLengthU(self._io, self, self._root) if self.has_field_mark_near_threshold: self.mark_near_threshold = self._io.read_f4le() if self.has_field_mark_selected_scale: self.mark_selected_scale = self._io.read_f4le() if self.has_field_reward_tip_slide_value: self.reward_tip_slide_value = self._io.read_f4le() if self.has_field_first_area_id_hide_mini_map: self.first_area_id_hide_mini_map = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_unlock_effect_delay: self.mark_unlock_effect_delay = self._io.read_f4le() @property def has_field_mini_map_scale_default(self): if hasattr(self, '_m_has_field_mini_map_scale_default'): return self._m_has_field_mini_map_scale_default self._m_has_field_mini_map_scale_default = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_mini_map_scale_default', None) @property def has_field_mini_map_ui_radius(self): if hasattr(self, '_m_has_field_mini_map_ui_radius'): return self._m_has_field_mini_map_ui_radius self._m_has_field_mini_map_ui_radius = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_mini_map_ui_radius', None) @property def has_field_level_map_custom_mark_near_cancel_radius(self): if hasattr(self, '_m_has_field_level_map_custom_mark_near_cancel_radius'): return self._m_has_field_level_map_custom_mark_near_cancel_radius self._m_has_field_level_map_custom_mark_near_cancel_radius = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_level_map_custom_mark_near_cancel_radius', None) @property def has_field_mini_map_scale_ranks(self): if hasattr(self, '_m_has_field_mini_map_scale_ranks'): return self._m_has_field_mini_map_scale_ranks self._m_has_field_mini_map_scale_ranks = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_mini_map_scale_ranks', None) @property def has_field_reward_tip_slide_value(self): if hasattr(self, '_m_has_field_reward_tip_slide_value'): return self._m_has_field_reward_tip_slide_value self._m_has_field_reward_tip_slide_value = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_reward_tip_slide_value', None) @property def has_field_first_area_id_hide_mini_map(self): if hasattr(self, '_m_has_field_first_area_id_hide_mini_map'): return self._m_has_field_first_area_id_hide_mini_map self._m_has_field_first_area_id_hide_mini_map = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_first_area_id_hide_mini_map', None) @property def has_field_level_map_scale_max(self): if hasattr(self, '_m_has_field_level_map_scale_max'): return self._m_has_field_level_map_scale_max self._m_has_field_level_map_scale_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_level_map_scale_max', None) @property def has_field_custom_styles(self): if hasattr(self, '_m_has_field_custom_styles'): return self._m_has_field_custom_styles self._m_has_field_custom_styles = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_custom_styles', None) @property def has_field_mini_map_sight_radius(self): if hasattr(self, '_m_has_field_mini_map_sight_radius'): return self._m_has_field_mini_map_sight_radius self._m_has_field_mini_map_sight_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_mini_map_sight_radius', None) @property def has_field_mark_near_threshold(self): if hasattr(self, '_m_has_field_mark_near_threshold'): return self._m_has_field_mark_near_threshold self._m_has_field_mark_near_threshold = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_mark_near_threshold', None) @property def has_field_mark_unlock_effect_delay(self): if hasattr(self, '_m_has_field_mark_unlock_effect_delay'): return self._m_has_field_mark_unlock_effect_delay self._m_has_field_mark_unlock_effect_delay = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_mark_unlock_effect_delay', None) @property def has_field_level_map_scale_min(self): if hasattr(self, '_m_has_field_level_map_scale_min'): return self._m_has_field_level_map_scale_min self._m_has_field_level_map_scale_min = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_level_map_scale_min', None) @property def has_field_mark_selected_scale(self): if hasattr(self, '_m_has_field_mark_selected_scale'): return self._m_has_field_mark_selected_scale self._m_has_field_mark_selected_scale = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_mark_selected_scale', None) @property def has_field_level_map_scale_default(self): if hasattr(self, '_m_has_field_level_map_scale_default'): return self._m_has_field_level_map_scale_default self._m_has_field_level_map_scale_default = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_level_map_scale_default', None) @property def has_field_level_map_custom_mark_cancel_radius(self): if hasattr(self, '_m_has_field_level_map_custom_mark_cancel_radius'): return self._m_has_field_level_map_custom_mark_cancel_radius self._m_has_field_level_map_custom_mark_cancel_radius = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_level_map_custom_mark_cancel_radius', None) @property def has_field_level_map_trans_point_radius(self): if hasattr(self, '_m_has_field_level_map_trans_point_radius'): return self._m_has_field_level_map_trans_point_radius self._m_has_field_level_map_trans_point_radius = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_level_map_trans_point_radius', None) class ServerMessageShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCoopDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class FeatureTagGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_i_ds: self.tag_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_tag_i_ds(self): if hasattr(self, '_m_has_field_tag_i_ds'): return self._m_has_field_tag_i_ds self._m_has_field_tag_i_ds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tag_i_ds', None) class DispConfigPerfItemOverrideInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigPerfStringKeyItemOverrideInfo(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigPerfBoolItemOverrideInfo(self._io, self, self._root) elif _on == 1: self.data = Output.PlayerCustomOptionConfig(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigPerfNumberArrayItemOverrideInfo(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigPerfGradeItemOverrideInfo(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigPerfNumberItemOverrideInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class LoadingTipsSituationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBornBySelfOwner(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class AddServerBuff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_s_buff_id: self.s_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time: self.time = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_s_buff_id(self): if hasattr(self, '_m_has_field_s_buff_id'): return self._m_has_field_s_buff_id self._m_has_field_s_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_s_buff_id', None) class ArrayOfConfigExternalVoiceInferiorItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigExternalVoiceInferiorItem(self._io, self, self._root)) class TargettingOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_range: self.range = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_range', None) class ConfigLightCore(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigConstForceField(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_name: self.trigger_name = AuxTypes.String(self._io, self, self._root) if self.has_field_core_trigger_name: self.core_trigger_name = AuxTypes.String(self._io, self, self._root) if self.has_field_max_absorb_time: self.max_absorb_time = self._io.read_f4le() if self.has_field_attenuation: self.attenuation = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_core_trigger_name(self): if hasattr(self, '_m_has_field_core_trigger_name'): return self._m_has_field_core_trigger_name self._m_has_field_core_trigger_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_core_trigger_name', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_cd', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def has_field_trigger_name(self): if hasattr(self, '_m_has_field_trigger_name'): return self._m_has_field_trigger_name self._m_has_field_trigger_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_name', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def velocity(self): if hasattr(self, '_m_velocity'): return self._m_velocity self._m_velocity = self.base.velocity return getattr(self, '_m_velocity', None) @property def has_field_max_absorb_time(self): if hasattr(self, '_m_has_field_max_absorb_time'): return self._m_has_field_max_absorb_time self._m_has_field_max_absorb_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_absorb_time', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class ConfigScenePropAnimatorMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class EnumAudioEmitterMultiPositionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AudioEmitterMultiPositionType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideFlyStartCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_height', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class TriggerTypeSupportMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ActivityPlantFlowerDailyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_daily_config_id: self.daily_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_item_list: self.cost_item_list = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_reward_id_list: self.reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_daily_config_id(self): if hasattr(self, '_m_has_field_daily_config_id'): return self._m_has_field_daily_config_id self._m_has_field_daily_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_daily_config_id', None) @property def has_field_cost_item_list(self): if hasattr(self, '_m_has_field_cost_item_list'): return self._m_has_field_cost_item_list self._m_has_field_cost_item_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cost_item_list', None) @property def has_field_reward_id_list(self): if hasattr(self, '_m_has_field_reward_id_list'): return self._m_has_field_reward_id_list self._m_has_field_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id_list', None) class EnumParentQuestState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ParentQuestState, self.data.value) return getattr(self, '_m_value', None) class BlessingPicUpConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prob: self.prob = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_prob(self): if hasattr(self, '_m_has_field_prob'): return self._m_has_field_prob self._m_has_field_prob = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prob', None) class MatchExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoubleIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumOrnamentsType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OrnamentsType, self.data.value) return getattr(self, '_m_value', None) class ForgeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_level: self.player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_show: self.is_default_show = self._io.read_u1() if self.has_field_effective_world_levels: self.effective_world_levels = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_forge_type: self.forge_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_item_id: self.show_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_consume_item_id: self.show_consume_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_result_item_id: self.result_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_result_item_count: self.result_item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_random_drop_id: self.main_random_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_forge_random_id: self.main_forge_random_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_forge_time: self.forge_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_queue_num: self.queue_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scoin_cost: self.scoin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_random_items: self.random_items = Output.ArrayOfRandomItemConfigLengthS(self._io, self, self._root) if self.has_field_material_items: self.material_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_forge_point: self.forge_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_forge_point_notice: self.forge_point_notice = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_result_item_count(self): if hasattr(self, '_m_has_field_result_item_count'): return self._m_has_field_result_item_count self._m_has_field_result_item_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_result_item_count', None) @property def has_field_forge_type(self): if hasattr(self, '_m_has_field_forge_type'): return self._m_has_field_forge_type self._m_has_field_forge_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_forge_type', None) @property def has_field_player_level(self): if hasattr(self, '_m_has_field_player_level'): return self._m_has_field_player_level self._m_has_field_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_player_level', None) @property def has_field_show_item_id(self): if hasattr(self, '_m_has_field_show_item_id'): return self._m_has_field_show_item_id self._m_has_field_show_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_item_id', None) @property def has_field_main_random_drop_id(self): if hasattr(self, '_m_has_field_main_random_drop_id'): return self._m_has_field_main_random_drop_id self._m_has_field_main_random_drop_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_main_random_drop_id', None) @property def has_field_random_items(self): if hasattr(self, '_m_has_field_random_items'): return self._m_has_field_random_items self._m_has_field_random_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_random_items', None) @property def has_field_scoin_cost(self): if hasattr(self, '_m_has_field_scoin_cost'): return self._m_has_field_scoin_cost self._m_has_field_scoin_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_scoin_cost', None) @property def has_field_is_default_show(self): if hasattr(self, '_m_has_field_is_default_show'): return self._m_has_field_is_default_show self._m_has_field_is_default_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_default_show', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_show_consume_item_id(self): if hasattr(self, '_m_has_field_show_consume_item_id'): return self._m_has_field_show_consume_item_id self._m_has_field_show_consume_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_show_consume_item_id', None) @property def has_field_forge_point(self): if hasattr(self, '_m_has_field_forge_point'): return self._m_has_field_forge_point self._m_has_field_forge_point = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_forge_point', None) @property def has_field_forge_time(self): if hasattr(self, '_m_has_field_forge_time'): return self._m_has_field_forge_time self._m_has_field_forge_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_forge_time', None) @property def has_field_result_item_id(self): if hasattr(self, '_m_has_field_result_item_id'): return self._m_has_field_result_item_id self._m_has_field_result_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_result_item_id', None) @property def has_field_effective_world_levels(self): if hasattr(self, '_m_has_field_effective_world_levels'): return self._m_has_field_effective_world_levels self._m_has_field_effective_world_levels = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effective_world_levels', None) @property def has_field_queue_num(self): if hasattr(self, '_m_has_field_queue_num'): return self._m_has_field_queue_num self._m_has_field_queue_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_queue_num', None) @property def has_field_main_forge_random_id(self): if hasattr(self, '_m_has_field_main_forge_random_id'): return self._m_has_field_main_forge_random_id self._m_has_field_main_forge_random_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_main_forge_random_id', None) @property def has_field_material_items(self): if hasattr(self, '_m_has_field_material_items'): return self._m_has_field_material_items self._m_has_field_material_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_material_items', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_forge_point_notice(self): if hasattr(self, '_m_has_field_forge_point_notice'): return self._m_has_field_forge_point_notice self._m_has_field_forge_point_notice = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_forge_point_notice', None) class H5activityCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAutoDool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_check_interval: self.check_interval = self._io.read_f4le() if self.has_field_trigger_distance: self.trigger_distance = self._io.read_f4le() @property def has_field_check_interval(self): if hasattr(self, '_m_has_field_check_interval'): return self._m_has_field_check_interval self._m_has_field_check_interval = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_check_interval', None) @property def has_field_trigger_distance(self): if hasattr(self, '_m_has_field_trigger_distance'): return self._m_has_field_trigger_distance self._m_has_field_trigger_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_distance', None) class ConfigCaptureGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_config: self.default_config = Output.ConfigCapture(self._io, self, self._root) @property def has_field_default_config(self): if hasattr(self, '_m_has_field_default_config'): return self._m_has_field_default_config self._m_has_field_default_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_config', None) class AnimatorParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReputationRequestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_request_id: self.request_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_request_id(self): if hasattr(self, '_m_has_field_request_id'): return self._m_has_field_request_id self._m_has_field_request_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_request_id', None) class TriggerModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByCurTeamHasBodyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_body_type: self.body_type = AuxTypes.String(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_body_type(self): if hasattr(self, '_m_has_field_body_type'): return self._m_has_field_body_type self._m_has_field_body_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_body_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfConfigCrowdTimeRestrictionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdTimeRestriction(self._io, self, self._root)) class ConfigTimeline(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseCutscene(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_sync_load: self.sync_load = self._io.read_u1() if self.has_field_fade_in_duration: self.fade_in_duration = self._io.read_f4le() if self.has_field_fade_out_duration: self.fade_out_duration = self._io.read_f4le() if self.has_field_force_gc: self.force_gc = self._io.read_u1() @property def direct_transmit(self): if hasattr(self, '_m_direct_transmit'): return self._m_direct_transmit self._m_direct_transmit = self.base.direct_transmit return getattr(self, '_m_direct_transmit', None) @property def has_field_sync_load(self): if hasattr(self, '_m_has_field_sync_load'): return self._m_has_field_sync_load self._m_has_field_sync_load = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sync_load', None) @property def lua_data_path(self): if hasattr(self, '_m_lua_data_path'): return self._m_lua_data_path self._m_lua_data_path = self.base.lua_data_path return getattr(self, '_m_lua_data_path', None) @property def clear_avatar_local_gadget(self): if hasattr(self, '_m_clear_avatar_local_gadget'): return self._m_clear_avatar_local_gadget self._m_clear_avatar_local_gadget = self.base.clear_avatar_local_gadget return getattr(self, '_m_clear_avatar_local_gadget', None) @property def can_skip(self): if hasattr(self, '_m_can_skip'): return self._m_can_skip self._m_can_skip = self.base.can_skip return getattr(self, '_m_can_skip', None) @property def disable_avatar_local_gadget(self): if hasattr(self, '_m_disable_avatar_local_gadget'): return self._m_disable_avatar_local_gadget self._m_disable_avatar_local_gadget = self.base.disable_avatar_local_gadget return getattr(self, '_m_disable_avatar_local_gadget', None) @property def target_pos(self): if hasattr(self, '_m_target_pos'): return self._m_target_pos self._m_target_pos = self.base.target_pos return getattr(self, '_m_target_pos', None) @property def clear_black_screen(self): if hasattr(self, '_m_clear_black_screen'): return self._m_clear_black_screen self._m_clear_black_screen = self.base.clear_black_screen return getattr(self, '_m_clear_black_screen', None) @property def attack_mode_recover(self): if hasattr(self, '_m_attack_mode_recover'): return self._m_attack_mode_recover self._m_attack_mode_recover = self.base.attack_mode_recover return getattr(self, '_m_attack_mode_recover', None) @property def disable_gpu_culling(self): if hasattr(self, '_m_disable_gpu_culling'): return self._m_disable_gpu_culling self._m_disable_gpu_culling = self.base.disable_gpu_culling return getattr(self, '_m_disable_gpu_culling', None) @property def can_player_loop(self): if hasattr(self, '_m_can_player_loop'): return self._m_can_player_loop self._m_can_player_loop = self.base.can_player_loop return getattr(self, '_m_can_player_loop', None) @property def cast_list_path(self): if hasattr(self, '_m_cast_list_path'): return self._m_cast_list_path self._m_cast_list_path = self.base.cast_list_path return getattr(self, '_m_cast_list_path', None) @property def use_target_pos(self): if hasattr(self, '_m_use_target_pos'): return self._m_use_target_pos self._m_use_target_pos = self.base.use_target_pos return getattr(self, '_m_use_target_pos', None) @property def force_can_skip(self): if hasattr(self, '_m_force_can_skip'): return self._m_force_can_skip self._m_force_can_skip = self.base.force_can_skip return getattr(self, '_m_force_can_skip', None) @property def start_pos_type(self): if hasattr(self, '_m_start_pos_type'): return self._m_start_pos_type self._m_start_pos_type = self.base.start_pos_type return getattr(self, '_m_start_pos_type', None) @property def need_xz_euler(self): if hasattr(self, '_m_need_xz_euler'): return self._m_need_xz_euler self._m_need_xz_euler = self.base.need_xz_euler return getattr(self, '_m_need_xz_euler', None) @property def start_offset(self): if hasattr(self, '_m_start_offset'): return self._m_start_offset self._m_start_offset = self.base.start_offset return getattr(self, '_m_start_offset', None) @property def modify_last_pose_offset(self): if hasattr(self, '_m_modify_last_pose_offset'): return self._m_modify_last_pose_offset self._m_modify_last_pose_offset = self.base.modify_last_pose_offset return getattr(self, '_m_modify_last_pose_offset', None) @property def entity_runtime_id(self): if hasattr(self, '_m_entity_runtime_id'): return self._m_entity_runtime_id self._m_entity_runtime_id = self.base.entity_runtime_id return getattr(self, '_m_entity_runtime_id', None) @property def enable_camera_displacement(self): if hasattr(self, '_m_enable_camera_displacement'): return self._m_enable_camera_displacement self._m_enable_camera_displacement = self.base.enable_camera_displacement return getattr(self, '_m_enable_camera_displacement', None) @property def has_field_fade_in_duration(self): if hasattr(self, '_m_has_field_fade_in_duration'): return self._m_has_field_fade_in_duration self._m_has_field_fade_in_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fade_in_duration', None) @property def fade_out_when_finish(self): if hasattr(self, '_m_fade_out_when_finish'): return self._m_fade_out_when_finish self._m_fade_out_when_finish = self.base.fade_out_when_finish return getattr(self, '_m_fade_out_when_finish', None) @property def skip_general_dialog(self): if hasattr(self, '_m_skip_general_dialog'): return self._m_skip_general_dialog self._m_skip_general_dialog = self.base.skip_general_dialog return getattr(self, '_m_skip_general_dialog', None) @property def main_quest_id(self): if hasattr(self, '_m_main_quest_id'): return self._m_main_quest_id self._m_main_quest_id = self.base.main_quest_id return getattr(self, '_m_main_quest_id', None) @property def entity_ban(self): if hasattr(self, '_m_entity_ban'): return self._m_entity_ban self._m_entity_ban = self.base.entity_ban return getattr(self, '_m_entity_ban', None) @property def can(self): if hasattr(self, '_m_can'): return self._m_can self._m_can = self.base.can return getattr(self, '_m_can', None) @property def has_field_force_gc(self): if hasattr(self, '_m_has_field_force_gc'): return self._m_has_field_force_gc self._m_has_field_force_gc = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_force_gc', None) @property def has_field_fade_out_duration(self): if hasattr(self, '_m_has_field_fade_out_duration'): return self._m_has_field_fade_out_duration self._m_has_field_fade_out_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fade_out_duration', None) @property def need_y_euler(self): if hasattr(self, '_m_need_y_euler'): return self._m_need_y_euler self._m_need_y_euler = self.base.need_y_euler return getattr(self, '_m_need_y_euler', None) @property def keep_camera(self): if hasattr(self, '_m_keep_camera'): return self._m_keep_camera self._m_keep_camera = self.base.keep_camera return getattr(self, '_m_keep_camera', None) @property def crowd_lod0list(self): if hasattr(self, '_m_crowd_lod0list'): return self._m_crowd_lod0list self._m_crowd_lod0list = self.base.crowd_lod0list return getattr(self, '_m_crowd_lod0list', None) @property def res_path(self): if hasattr(self, '_m_res_path'): return self._m_res_path self._m_res_path = self.base.res_path return getattr(self, '_m_res_path', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_task_cfg(self): if hasattr(self, '_m_pre_task_cfg'): return self._m_pre_task_cfg self._m_pre_task_cfg = self.base.pre_task_cfg return getattr(self, '_m_pre_task_cfg', None) @property def delay_transmit(self): if hasattr(self, '_m_delay_transmit'): return self._m_delay_transmit self._m_delay_transmit = self.base.delay_transmit return getattr(self, '_m_delay_transmit', None) class ArrayOfRandomItemConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RandomItemConfig(self._io, self, self._root)) class ArrayOfEnumAbilityStateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumAbilityState(self._io, self, self._root)) class NewActivityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DistTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2fireworksChallengeDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_factor_id_list: self.factor_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_fire_element_value: self.init_fire_element_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_full_score: self.full_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_ability_score: self.unlock_ability_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_fireworks_score: self.unlock_fireworks_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_add_stamina_value: self.add_stamina_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_init_fire_element_value(self): if hasattr(self, '_m_has_field_init_fire_element_value'): return self._m_has_field_init_fire_element_value self._m_has_field_init_fire_element_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_init_fire_element_value', None) @property def has_field_full_score(self): if hasattr(self, '_m_has_field_full_score'): return self._m_has_field_full_score self._m_has_field_full_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_full_score', None) @property def has_field_factor_id_list(self): if hasattr(self, '_m_has_field_factor_id_list'): return self._m_has_field_factor_id_list self._m_has_field_factor_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_factor_id_list', None) @property def has_field_unlock_fireworks_score(self): if hasattr(self, '_m_has_field_unlock_fireworks_score'): return self._m_has_field_unlock_fireworks_score self._m_has_field_unlock_fireworks_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_fireworks_score', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_unlock_ability_score(self): if hasattr(self, '_m_has_field_unlock_ability_score'): return self._m_has_field_unlock_ability_score self._m_has_field_unlock_ability_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_ability_score', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_challenge_id', None) @property def has_field_add_stamina_value(self): if hasattr(self, '_m_has_field_add_stamina_value'): return self._m_has_field_add_stamina_value self._m_has_field_add_stamina_value = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_add_stamina_value', None) class ReleaseAiActionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_point_type: self.point_type = Output.EnumActionPointType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigRecordMaterialParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_material_type: self.material_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_texture_names: self.texture_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_floats: self.floats = Output.ArrayOfMaterialFloatLengthU(self._io, self, self._root) @property def has_field_material_type(self): if hasattr(self, '_m_has_field_material_type'): return self._m_has_field_material_type self._m_has_field_material_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_material_type', None) @property def has_field_texture_names(self): if hasattr(self, '_m_has_field_texture_names'): return self._m_has_field_texture_names self._m_has_field_texture_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_texture_names', None) @property def has_field_floats(self): if hasattr(self, '_m_has_field_floats'): return self._m_has_field_floats self._m_has_field_floats = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_floats', None) class RegionalPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPhotographCheck(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_all_judge_nodes: self.all_judge_nodes = Output.DictOfAuxTypesVlqBase128LeUDispConfigJudgeNodeBase(self._io, self, self._root) @property def has_field_all_judge_nodes(self): if hasattr(self, '_m_has_field_all_judge_nodes'): return self._m_has_field_all_judge_nodes self._m_has_field_all_judge_nodes = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_all_judge_nodes', None) class ConfigMusicGameCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_camera_config_list: self.camera_config_list = Output.ArrayOfConfigMusicCameraLengthU(self._io, self, self._root) @property def has_field_camera_config_list(self): if hasattr(self, '_m_has_field_camera_config_list'): return self._m_has_field_camera_config_list self._m_has_field_camera_config_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_config_list', None) class EnvAnimalWeightExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_env_type: self.env_type = Output.EnumEnvironmentType(self._io, self, self._root) if self.has_field_weight_vec: self.weight_vec = Output.ArrayOfEnvironmentWeightTypeLengthS(self._io, self, self._root) @property def has_field_env_type(self): if hasattr(self, '_m_has_field_env_type'): return self._m_has_field_env_type self._m_has_field_env_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_env_type', None) @property def has_field_weight_vec(self): if hasattr(self, '_m_has_field_weight_vec'): return self._m_has_field_weight_vec self._m_has_field_weight_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weight_vec', None) class ByHasAttackTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ByIsLocalAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class RogueTokenExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cell_type: self.cell_type = Output.EnumRogueMonsterPoolDifficultyType(self._io, self, self._root) if self.has_field_coin_a_num: self.coin_a_num = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_coin_b_num: self.coin_b_num = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_coin_c_num: self.coin_c_num = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_cell_type(self): if hasattr(self, '_m_has_field_cell_type'): return self._m_has_field_cell_type self._m_has_field_cell_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cell_type', None) @property def has_field_coin_c_num(self): if hasattr(self, '_m_has_field_coin_c_num'): return self._m_has_field_coin_c_num self._m_has_field_coin_c_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_coin_c_num', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_coin_a_num(self): if hasattr(self, '_m_has_field_coin_a_num'): return self._m_has_field_coin_a_num self._m_has_field_coin_a_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_coin_a_num', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_coin_b_num(self): if hasattr(self, '_m_has_field_coin_b_num'): return self._m_has_field_coin_b_num self._m_has_field_coin_b_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_coin_b_num', None) class GadgetInteractActionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_action_type: self.action_type = Output.EnumInteractActionType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_action_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ConfigGuideTeamAvatarNumCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_avatar_num: self.avatar_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_opt: self.opt = Output.EnumGuideOperator(self._io, self, self._root) @property def has_field_avatar_num(self): if hasattr(self, '_m_has_field_avatar_num'): return self._m_has_field_avatar_num self._m_has_field_avatar_num = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_avatar_num', None) @property def has_field_opt(self): if hasattr(self, '_m_has_field_opt'): return self._m_has_field_opt self._m_has_field_opt = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_opt', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ReunionCommercialExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_domestic_link: self.domestic_link = AuxTypes.String(self._io, self, self._root) if self.has_field_oversea_link: self.oversea_link = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_domestic_link(self): if hasattr(self, '_m_has_field_domestic_link'): return self._m_has_field_domestic_link self._m_has_field_domestic_link = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_domestic_link', None) @property def has_field_oversea_link(self): if hasattr(self, '_m_has_field_oversea_link'): return self._m_has_field_oversea_link self._m_has_field_oversea_link = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_oversea_link', None) class EnableHitBoxByName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_box_names: self.hit_box_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_hit_box_names(self): if hasattr(self, '_m_has_field_hit_box_names'): return self._m_has_field_hit_box_names self._m_has_field_hit_box_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_box_names', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ProductPs4packageDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_content_vec: self.content_vec = Output.ArrayOfPackageContentConfigLengthS(self._io, self, self._root) if self.has_field_mail_config_id: self.mail_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_content_vec(self): if hasattr(self, '_m_has_field_content_vec'): return self._m_has_field_content_vec self._m_has_field_content_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_content_vec', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_mail_config_id(self): if hasattr(self, '_m_has_field_mail_config_id'): return self._m_has_field_mail_config_id self._m_has_field_mail_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mail_config_id', None) class GlobalWatcherConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_predicate_configs: self.predicate_configs = Output.ArrayOfWatcherPredicateConfigLengthS(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_config: self.trigger_config = Output.WatcherTriggerConfig(self._io, self, self._root) if self.has_field_progress: self.progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_predicate_configs(self): if hasattr(self, '_m_has_field_predicate_configs'): return self._m_has_field_predicate_configs self._m_has_field_predicate_configs = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_predicate_configs', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_progress(self): if hasattr(self, '_m_has_field_progress'): return self._m_has_field_progress self._m_has_field_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_progress', None) @property def has_field_trigger_config(self): if hasattr(self, '_m_has_field_trigger_config'): return self._m_has_field_trigger_config self._m_has_field_trigger_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_trigger_config', None) class ConfigAbilityTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_async: self.is_async = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_delay: self.delay = self._io.read_f4le() @property def has_field_is_async(self): if hasattr(self, '_m_has_field_is_async'): return self._m_has_field_is_async self._m_has_field_is_async = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_async', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_delay(self): if hasattr(self, '_m_has_field_delay'): return self._m_has_field_delay self._m_has_field_delay = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_delay', None) class HuntingCluePointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigAiMixinSetFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetFloat(self._io, self, self._root)) class ModifySkillPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_delta: self.point_delta = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_point_delta(self): if hasattr(self, '_m_has_field_point_delta'): return self._m_has_field_point_delta self._m_has_field_point_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_point_delta', None) class ConfigRewardTips(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_type: self.mark_type = Output.EnumMarkType(self._io, self, self._root) if self.has_field_mark_icon_type_list: self.mark_icon_type_list = Output.ArrayOfEnumMarkIconTypeLengthU(self._io, self, self._root) if self.has_field_use_trans_points: self.use_trans_points = self._io.read_u1() if self.has_field_near_city: self.near_city = self._io.read_u1() if self.has_field_show_reward_map_tag: self.show_reward_map_tag = self._io.read_u1() if self.has_field_show_high_light: self.show_high_light = self._io.read_u1() @property def has_field_show_high_light(self): if hasattr(self, '_m_has_field_show_high_light'): return self._m_has_field_show_high_light self._m_has_field_show_high_light = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_show_high_light', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_title', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_mark_type(self): if hasattr(self, '_m_has_field_mark_type'): return self._m_has_field_mark_type self._m_has_field_mark_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_mark_type', None) @property def has_field_near_city(self): if hasattr(self, '_m_has_field_near_city'): return self._m_has_field_near_city self._m_has_field_near_city = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_near_city', None) @property def has_field_use_trans_points(self): if hasattr(self, '_m_has_field_use_trans_points'): return self._m_has_field_use_trans_points self._m_has_field_use_trans_points = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_trans_points', None) @property def has_field_show_reward_map_tag(self): if hasattr(self, '_m_has_field_show_reward_map_tag'): return self._m_has_field_show_reward_map_tag self._m_has_field_show_reward_map_tag = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_show_reward_map_tag', None) @property def has_field_mark_icon_type_list(self): if hasattr(self, '_m_has_field_mark_icon_type_list'): return self._m_has_field_mark_icon_type_list self._m_has_field_mark_icon_type_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_mark_icon_type_list', None) class ConfigGlobalInteraction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_talk_enable_angle: self.talk_enable_angle = self._io.read_f4le() if self.has_field_head_ctrl_enable_angle: self.head_ctrl_enable_angle = self._io.read_f4le() if self.has_field_head_ctrl_disable_angle: self.head_ctrl_disable_angle = self._io.read_f4le() @property def has_field_talk_enable_angle(self): if hasattr(self, '_m_has_field_talk_enable_angle'): return self._m_has_field_talk_enable_angle self._m_has_field_talk_enable_angle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talk_enable_angle', None) @property def has_field_head_ctrl_enable_angle(self): if hasattr(self, '_m_has_field_head_ctrl_enable_angle'): return self._m_has_field_head_ctrl_enable_angle self._m_has_field_head_ctrl_enable_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_head_ctrl_enable_angle', None) @property def has_field_head_ctrl_disable_angle(self): if hasattr(self, '_m_has_field_head_ctrl_disable_angle'): return self._m_has_field_head_ctrl_disable_angle self._m_has_field_head_ctrl_disable_angle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_head_ctrl_disable_angle', None) class ConfigAbilityRecordData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_code_version: self.code_version = AuxTypes.String(self._io, self, self._root) if self.has_field_digit_version: self.digit_version = AuxTypes.String(self._io, self, self._root) if self.has_field_date_time: self.date_time = AuxTypes.String(self._io, self, self._root) if self.has_field_data: self.data = Output.ArrayOfConfigAbilityFrameDataLengthU(self._io, self, self._root) @property def has_field_code_version(self): if hasattr(self, '_m_has_field_code_version'): return self._m_has_field_code_version self._m_has_field_code_version = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_code_version', None) @property def has_field_digit_version(self): if hasattr(self, '_m_has_field_digit_version'): return self._m_has_field_digit_version self._m_has_field_digit_version = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_digit_version', None) @property def has_field_date_time(self): if hasattr(self, '_m_has_field_date_time'): return self._m_has_field_date_time self._m_has_field_date_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_date_time', None) @property def has_field_data(self): if hasattr(self, '_m_has_field_data'): return self._m_has_field_data self._m_has_field_data = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_data', None) class EnumAvatarStageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AvatarStageType, self.data.value) return getattr(self, '_m_value', None) class ActivitySalesmanExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_config_id_list: self.daily_config_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_normal_reward_id_list: self.normal_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_reward_id_list: self.special_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_prob_list: self.special_prob_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_special_reward: self.special_reward = Output.SalesmanSpecialReward(self._io, self, self._root) @property def has_field_special_prob_list(self): if hasattr(self, '_m_has_field_special_prob_list'): return self._m_has_field_special_prob_list self._m_has_field_special_prob_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_special_prob_list', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_daily_config_id_list(self): if hasattr(self, '_m_has_field_daily_config_id_list'): return self._m_has_field_daily_config_id_list self._m_has_field_daily_config_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_daily_config_id_list', None) @property def has_field_special_reward(self): if hasattr(self, '_m_has_field_special_reward'): return self._m_has_field_special_reward self._m_has_field_special_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_special_reward', None) @property def has_field_special_reward_id_list(self): if hasattr(self, '_m_has_field_special_reward_id_list'): return self._m_has_field_special_reward_id_list self._m_has_field_special_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_special_reward_id_list', None) @property def has_field_normal_reward_id_list(self): if hasattr(self, '_m_has_field_normal_reward_id_list'): return self._m_has_field_normal_reward_id_list self._m_has_field_normal_reward_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_normal_reward_id_list', None) class EnumIrodoriPoetryEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriPoetryEntityType, self.data.value) return getattr(self, '_m_value', None) class CreateItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.CreateEntity(self._io, self, self._root) @property def owner_is_target(self): if hasattr(self, '_m_owner_is_target'): return self._m_owner_is_target self._m_owner_is_target = self.base.owner_is_target return getattr(self, '_m_owner_is_target', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def sight_group_with_owner(self): if hasattr(self, '_m_sight_group_with_owner'): return self._m_sight_group_with_owner self._m_sight_group_with_owner = self.base.sight_group_with_owner return getattr(self, '_m_sight_group_with_owner', None) @property def born(self): if hasattr(self, '_m_born'): return self._m_born self._m_born = self.base.born return getattr(self, '_m_born', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def life_by_owner_is_alive(self): if hasattr(self, '_m_life_by_owner_is_alive'): return self._m_life_by_owner_is_alive self._m_life_by_owner_is_alive = self.base.life_by_owner_is_alive return getattr(self, '_m_life_by_owner_is_alive', None) @property def life_by_owner_v2(self): if hasattr(self, '_m_life_by_owner_v2'): return self._m_life_by_owner_v2 self._m_life_by_owner_v2 = self.base.life_by_owner_v2 return getattr(self, '_m_life_by_owner_v2', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def is_peer_id_from_player(self): if hasattr(self, '_m_is_peer_id_from_player'): return self._m_is_peer_id_from_player self._m_is_peer_id_from_player = self.base.is_peer_id_from_player return getattr(self, '_m_is_peer_id_from_player', None) @property def dont_kill_self_by_client_prediction(self): if hasattr(self, '_m_dont_kill_self_by_client_prediction'): return self._m_dont_kill_self_by_client_prediction self._m_dont_kill_self_by_client_prediction = self.base.dont_kill_self_by_client_prediction return getattr(self, '_m_dont_kill_self_by_client_prediction', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def prop_owner_is(self): if hasattr(self, '_m_prop_owner_is'): return self._m_prop_owner_is self._m_prop_owner_is = self.base.prop_owner_is return getattr(self, '_m_prop_owner_is', None) @property def owner_is(self): if hasattr(self, '_m_owner_is'): return self._m_owner_is self._m_owner_is = self.base.owner_is return getattr(self, '_m_owner_is', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def check_ground(self): if hasattr(self, '_m_check_ground'): return self._m_check_ground self._m_check_ground = self.base.check_ground return getattr(self, '_m_check_ground', None) class ArrayOfEquipSizeDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EquipSizeData(self._io, self, self._root)) class ByHitImpulse(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_impulse: self.hit_impulse = self._io.read_f4le() @property def has_field_hit_impulse(self): if hasattr(self, '_m_has_field_hit_impulse'): return self._m_has_field_hit_impulse self._m_has_field_hit_impulse = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_impulse', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ProductAppleGiftCardDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringDictOfAuxTypesStringF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDictOfAuxTypesStringF4(self._io, self, self._root)) class OpActivityTrackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShowScreenEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_type: self.effect_type = Output.EnumEffectType(self._io, self, self._root) if self.has_field_show: self.show = self._io.read_u1() @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_type', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_show', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigLoadingDoor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_room1: self.room1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room2: self.room2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def has_field_room1(self): if hasattr(self, '_m_has_field_room1'): return self._m_has_field_room1 self._m_has_field_room1 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_room1', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_room2(self): if hasattr(self, '_m_has_field_room2'): return self._m_has_field_room2 self._m_has_field_room2 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_room2', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class ArrayOfQuestExecExLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestExecEx(self._io, self, self._root)) class ConfigResonanceCutSceneMap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cutscene_map: self.cutscene_map = Output.DictOfEnumElementTypeConfigResonanceCutScene(self._io, self, self._root) @property def has_field_cutscene_map(self): if hasattr(self, '_m_has_field_cutscene_map'): return self._m_has_field_cutscene_map self._m_has_field_cutscene_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cutscene_map', None) class PlayerCustomOptionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_option_text_name: self.option_text_name = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_perf_cost_ratio: self.perf_cost_ratio = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) @property def has_field_option_text_name(self): if hasattr(self, '_m_has_field_option_text_name'): return self._m_has_field_option_text_name self._m_has_field_option_text_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_option_text_name', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def has_field_perf_cost_ratio(self): if hasattr(self, '_m_has_field_perf_cost_ratio'): return self._m_has_field_perf_cost_ratio self._m_has_field_perf_cost_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_perf_cost_ratio', None) class ConfigAudioWeather(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_transition_rtpc_key: self.transition_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dominant_state_name: self.dominant_state_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dominant_switch_name: self.dominant_switch_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dominant_rtpc_key: self.dominant_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dominant_state_name_without_delay: self.dominant_state_name_without_delay = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dominant_rtpc_key_without_delay: self.dominant_rtpc_key_without_delay = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_time_of_day_rtpc_key: self.time_of_day_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_avatar_speech_event: self.avatar_speech_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_weather_state_map: self.weather_state_map = Output.DictOfAuxTypesStringAudioWeatherProperties(self._io, self, self._root) if self.has_field_workset1: self.workset1 = Output.AudioWeatherWorkSet(self._io, self, self._root) if self.has_field_workset2: self.workset2 = Output.AudioWeatherWorkSet(self._io, self, self._root) if self.has_field_near_thunder_start: self.near_thunder_start = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_near_thunder_end: self.near_thunder_end = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_distant_thunder_start: self.distant_thunder_start = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_distant_thunder_end: self.distant_thunder_end = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_sky_thunder: self.sky_thunder = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_workset_switch_key: self.workset_switch_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_wind_speed_rtpc_key: self.wind_speed_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_wind_direction_rtpc_key: self.wind_direction_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_climate_rtpc_key: self.climate_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_climate_rtpc_map: self.climate_rtpc_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_weather_voice_triggers: self.weather_voice_triggers = Output.ArrayOfAudioWeatherVoTriggerLengthU(self._io, self, self._root) if self.has_field_thunder_voice_trigger: self.thunder_voice_trigger = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_thunder_voice_cooldown: self.thunder_voice_cooldown = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enviro_time_rtpc_key: self.enviro_time_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_angle_between_wind_and_listener_rtpc_key: self.angle_between_wind_and_listener_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_angle_static_update_rate: self.angle_static_update_rate = self._io.read_f4le() if self.has_field_angle_dynamic_update_rate: self.angle_dynamic_update_rate = self._io.read_f4le() @property def has_field_weather_voice_triggers(self): if hasattr(self, '_m_has_field_weather_voice_triggers'): return self._m_has_field_weather_voice_triggers self._m_has_field_weather_voice_triggers = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_weather_voice_triggers', None) @property def has_field_angle_between_wind_and_listener_rtpc_key(self): if hasattr(self, '_m_has_field_angle_between_wind_and_listener_rtpc_key'): return self._m_has_field_angle_between_wind_and_listener_rtpc_key self._m_has_field_angle_between_wind_and_listener_rtpc_key = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_angle_between_wind_and_listener_rtpc_key', None) @property def has_field_workset1(self): if hasattr(self, '_m_has_field_workset1'): return self._m_has_field_workset1 self._m_has_field_workset1 = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_workset1', None) @property def has_field_wind_direction_rtpc_key(self): if hasattr(self, '_m_has_field_wind_direction_rtpc_key'): return self._m_has_field_wind_direction_rtpc_key self._m_has_field_wind_direction_rtpc_key = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_wind_direction_rtpc_key', None) @property def has_field_dominant_rtpc_key_without_delay(self): if hasattr(self, '_m_has_field_dominant_rtpc_key_without_delay'): return self._m_has_field_dominant_rtpc_key_without_delay self._m_has_field_dominant_rtpc_key_without_delay = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_dominant_rtpc_key_without_delay', None) @property def has_field_distant_thunder_start(self): if hasattr(self, '_m_has_field_distant_thunder_start'): return self._m_has_field_distant_thunder_start self._m_has_field_distant_thunder_start = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_distant_thunder_start', None) @property def has_field_angle_dynamic_update_rate(self): if hasattr(self, '_m_has_field_angle_dynamic_update_rate'): return self._m_has_field_angle_dynamic_update_rate self._m_has_field_angle_dynamic_update_rate = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_angle_dynamic_update_rate', None) @property def has_field_enviro_time_rtpc_key(self): if hasattr(self, '_m_has_field_enviro_time_rtpc_key'): return self._m_has_field_enviro_time_rtpc_key self._m_has_field_enviro_time_rtpc_key = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_enviro_time_rtpc_key', None) @property def has_field_workset2(self): if hasattr(self, '_m_has_field_workset2'): return self._m_has_field_workset2 self._m_has_field_workset2 = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_workset2', None) @property def has_field_angle_static_update_rate(self): if hasattr(self, '_m_has_field_angle_static_update_rate'): return self._m_has_field_angle_static_update_rate self._m_has_field_angle_static_update_rate = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_angle_static_update_rate', None) @property def has_field_distant_thunder_end(self): if hasattr(self, '_m_has_field_distant_thunder_end'): return self._m_has_field_distant_thunder_end self._m_has_field_distant_thunder_end = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_distant_thunder_end', None) @property def has_field_near_thunder_end(self): if hasattr(self, '_m_has_field_near_thunder_end'): return self._m_has_field_near_thunder_end self._m_has_field_near_thunder_end = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_near_thunder_end', None) @property def has_field_transition_rtpc_key(self): if hasattr(self, '_m_has_field_transition_rtpc_key'): return self._m_has_field_transition_rtpc_key self._m_has_field_transition_rtpc_key = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_transition_rtpc_key', None) @property def has_field_time_of_day_rtpc_key(self): if hasattr(self, '_m_has_field_time_of_day_rtpc_key'): return self._m_has_field_time_of_day_rtpc_key self._m_has_field_time_of_day_rtpc_key = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_time_of_day_rtpc_key', None) @property def has_field_weather_state_map(self): if hasattr(self, '_m_has_field_weather_state_map'): return self._m_has_field_weather_state_map self._m_has_field_weather_state_map = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_weather_state_map', None) @property def has_field_near_thunder_start(self): if hasattr(self, '_m_has_field_near_thunder_start'): return self._m_has_field_near_thunder_start self._m_has_field_near_thunder_start = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_near_thunder_start', None) @property def has_field_sky_thunder(self): if hasattr(self, '_m_has_field_sky_thunder'): return self._m_has_field_sky_thunder self._m_has_field_sky_thunder = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_sky_thunder', None) @property def has_field_dominant_rtpc_key(self): if hasattr(self, '_m_has_field_dominant_rtpc_key'): return self._m_has_field_dominant_rtpc_key self._m_has_field_dominant_rtpc_key = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_dominant_rtpc_key', None) @property def has_field_avatar_speech_event(self): if hasattr(self, '_m_has_field_avatar_speech_event'): return self._m_has_field_avatar_speech_event self._m_has_field_avatar_speech_event = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_avatar_speech_event', None) @property def has_field_dominant_state_name(self): if hasattr(self, '_m_has_field_dominant_state_name'): return self._m_has_field_dominant_state_name self._m_has_field_dominant_state_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_dominant_state_name', None) @property def has_field_climate_rtpc_key(self): if hasattr(self, '_m_has_field_climate_rtpc_key'): return self._m_has_field_climate_rtpc_key self._m_has_field_climate_rtpc_key = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_climate_rtpc_key', None) @property def has_field_thunder_voice_trigger(self): if hasattr(self, '_m_has_field_thunder_voice_trigger'): return self._m_has_field_thunder_voice_trigger self._m_has_field_thunder_voice_trigger = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_thunder_voice_trigger', None) @property def has_field_wind_speed_rtpc_key(self): if hasattr(self, '_m_has_field_wind_speed_rtpc_key'): return self._m_has_field_wind_speed_rtpc_key self._m_has_field_wind_speed_rtpc_key = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_wind_speed_rtpc_key', None) @property def has_field_thunder_voice_cooldown(self): if hasattr(self, '_m_has_field_thunder_voice_cooldown'): return self._m_has_field_thunder_voice_cooldown self._m_has_field_thunder_voice_cooldown = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_thunder_voice_cooldown', None) @property def has_field_dominant_switch_name(self): if hasattr(self, '_m_has_field_dominant_switch_name'): return self._m_has_field_dominant_switch_name self._m_has_field_dominant_switch_name = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_dominant_switch_name', None) @property def has_field_climate_rtpc_map(self): if hasattr(self, '_m_has_field_climate_rtpc_map'): return self._m_has_field_climate_rtpc_map self._m_has_field_climate_rtpc_map = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_climate_rtpc_map', None) @property def has_field_dominant_state_name_without_delay(self): if hasattr(self, '_m_has_field_dominant_state_name_without_delay'): return self._m_has_field_dominant_state_name_without_delay self._m_has_field_dominant_state_name_without_delay = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_dominant_state_name_without_delay', None) @property def has_field_workset_switch_key(self): if hasattr(self, '_m_has_field_workset_switch_key'): return self._m_has_field_workset_switch_key self._m_has_field_workset_switch_key = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_workset_switch_key', None) class ConfigMusicMultiValueParameterizedStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterizedStimulusHandler(self._io, self, self._root) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class ConfigDirectionByGroundNormal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class ActivityPhotographExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AddTalentExtraLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_talent_type: self.talent_type = Output.EnumTalentType(self._io, self, self._root) if self.has_field_talent_index: self.talent_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_level: self.extra_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_talent_type(self): if hasattr(self, '_m_has_field_talent_type'): return self._m_has_field_talent_type self._m_has_field_talent_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talent_type', None) @property def has_field_talent_index(self): if hasattr(self, '_m_has_field_talent_index'): return self._m_has_field_talent_index self._m_has_field_talent_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_talent_index', None) @property def has_field_extra_level(self): if hasattr(self, '_m_has_field_extra_level'): return self._m_has_field_extra_level self._m_has_field_extra_level = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_extra_level', None) class EchoShellStoryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_title: self.story_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_story_title(self): if hasattr(self, '_m_has_field_story_title'): return self._m_has_field_story_title self._m_has_field_story_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_story_title', None) class H5activityWatcherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForceInitMassiveEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_angle: self.angle = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_height', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_angle(self): if hasattr(self, '_m_has_field_angle'): return self._m_has_field_angle self._m_has_field_angle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_angle', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class EnumExhibitionSeriesType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionSeriesType, self.data.value) return getattr(self, '_m_value', None) class ConfigAbilitySystem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_should_pre_active: self.should_pre_active = self._io.read_u1() if self.has_field_tasks: self.tasks = Output.ArrayOfDispConfigAbilityTaskLengthU(self._io, self, self._root) @property def has_field_should_pre_active(self): if hasattr(self, '_m_has_field_should_pre_active'): return self._m_has_field_should_pre_active self._m_has_field_should_pre_active = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_should_pre_active', None) @property def has_field_tasks(self): if hasattr(self, '_m_has_field_tasks'): return self._m_has_field_tasks self._m_has_field_tasks = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tasks', None) class MechanicBuildingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCustomLevelRoomBasic(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_deploy_start_pos: self.deploy_start_pos = Output.Vector(self._io, self, self._root) if self.has_field_deploy_bound: self.deploy_bound = Output.Vector(self._io, self, self._root) if self.has_field_total_cost: self.total_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_rooms: self.pre_rooms = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_next_rooms: self.next_rooms = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_born_pos: self.born_pos = Output.Vector(self._io, self, self._root) if self.has_field_born_rot: self.born_rot = Output.Vector(self._io, self, self._root) @property def has_field_born_rot(self): if hasattr(self, '_m_has_field_born_rot'): return self._m_has_field_born_rot self._m_has_field_born_rot = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_born_rot', None) @property def has_field_pre_rooms(self): if hasattr(self, '_m_has_field_pre_rooms'): return self._m_has_field_pre_rooms self._m_has_field_pre_rooms = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_pre_rooms', None) @property def has_field_next_rooms(self): if hasattr(self, '_m_has_field_next_rooms'): return self._m_has_field_next_rooms self._m_has_field_next_rooms = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_next_rooms', None) @property def has_field_deploy_bound(self): if hasattr(self, '_m_has_field_deploy_bound'): return self._m_has_field_deploy_bound self._m_has_field_deploy_bound = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_deploy_bound', None) @property def has_field_born_pos(self): if hasattr(self, '_m_has_field_born_pos'): return self._m_has_field_born_pos self._m_has_field_born_pos = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_born_pos', None) @property def has_field_deploy_start_pos(self): if hasattr(self, '_m_has_field_deploy_start_pos'): return self._m_has_field_deploy_start_pos self._m_has_field_deploy_start_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_deploy_start_pos', None) @property def has_field_total_cost(self): if hasattr(self, '_m_has_field_total_cost'): return self._m_has_field_total_cost self._m_has_field_total_cost = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_total_cost', None) class DocumentExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content_localized_id: self.content_localized_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_path: self.preview_path = AuxTypes.String(self._io, self, self._root) if self.has_field_document_type: self.document_type = Output.EnumDocumentType(self._io, self, self._root) if self.has_field_video_path: self.video_path = AuxTypes.String(self._io, self, self._root) if self.has_field_subtitle_id: self.subtitle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_subtitle_id(self): if hasattr(self, '_m_has_field_subtitle_id'): return self._m_has_field_subtitle_id self._m_has_field_subtitle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_subtitle_id', None) @property def has_field_video_path(self): if hasattr(self, '_m_has_field_video_path'): return self._m_has_field_video_path self._m_has_field_video_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_video_path', None) @property def has_field_content_localized_id(self): if hasattr(self, '_m_has_field_content_localized_id'): return self._m_has_field_content_localized_id self._m_has_field_content_localized_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content_localized_id', None) @property def has_field_preview_path(self): if hasattr(self, '_m_has_field_preview_path'): return self._m_has_field_preview_path self._m_has_field_preview_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_preview_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_document_type(self): if hasattr(self, '_m_has_field_document_type'): return self._m_has_field_document_type self._m_has_field_document_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_document_type', None) class BookSuitExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigQuestSchemeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigQuestScheme(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeSConfigAiPatrolFollowData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiPatrolFollowData(self._io, self, self._root) class ConfigAiCastRangeXzY(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cast_range_xz_min: self.cast_range_xz_min = self._io.read_f4le() if self.has_field_cast_range_xz_max: self.cast_range_xz_max = self._io.read_f4le() if self.has_field_cast_range_y_min: self.cast_range_y_min = self._io.read_f4le() if self.has_field_cast_range_y_max: self.cast_range_y_max = self._io.read_f4le() @property def has_field_cast_range_xz_min(self): if hasattr(self, '_m_has_field_cast_range_xz_min'): return self._m_has_field_cast_range_xz_min self._m_has_field_cast_range_xz_min = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cast_range_xz_min', None) @property def has_field_cast_range_xz_max(self): if hasattr(self, '_m_has_field_cast_range_xz_max'): return self._m_has_field_cast_range_xz_max self._m_has_field_cast_range_xz_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cast_range_xz_max', None) @property def has_field_cast_range_y_min(self): if hasattr(self, '_m_has_field_cast_range_y_min'): return self._m_has_field_cast_range_y_min self._m_has_field_cast_range_y_min = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cast_range_y_min', None) @property def has_field_cast_range_y_max(self): if hasattr(self, '_m_has_field_cast_range_y_max'): return self._m_has_field_cast_range_y_max self._m_has_field_cast_range_y_max = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cast_range_y_max', None) class ConfigMusicUInt32listAllPresenceCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32listMultiMemberCondition(self._io, self, self._root) @property def values(self): if hasattr(self, '_m_values'): return self._m_values self._m_values = self.base.values return getattr(self, '_m_values', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CodexQuestTextTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityShopSheetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestType, self.data.value) return getattr(self, '_m_value', None) class ActivityHachiFinalStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicUIntMultiValueStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicMultiValueParameterizedStimulusHandler(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_uint_params: self.uint_params = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_uint_params(self): if hasattr(self, '_m_has_field_uint_params'): return self._m_has_field_uint_params self._m_has_field_uint_params = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_uint_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class CallLuaTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_alias: self.target_alias = AuxTypes.String(self._io, self, self._root) if self.has_field_value_int: self.value_int = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_value_float: self.value_float = self._io.read_f4le() if self.has_field_value_string: self.value_string = AuxTypes.String(self._io, self, self._root) @property def has_field_target_alias(self): if hasattr(self, '_m_has_field_target_alias'): return self._m_has_field_target_alias self._m_has_field_target_alias = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_alias', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value_float(self): if hasattr(self, '_m_has_field_value_float'): return self._m_has_field_value_float self._m_has_field_value_float = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value_float', None) @property def has_field_value_string(self): if hasattr(self, '_m_has_field_value_string'): return self._m_has_field_value_string self._m_has_field_value_string = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_value_string', None) @property def has_field_value_int(self): if hasattr(self, '_m_has_field_value_int'): return self._m_has_field_value_int self._m_has_field_value_int = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value_int', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ModifyDamageCountMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ModifyDamageMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_max_modify_count: self.max_modify_count = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_count_predicates: self.count_predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_is_ignore_attenuation: self.is_ignore_attenuation = self._io.read_u1() if self.has_field_success_actions: self.success_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_max_count_actions: self.max_count_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def damage_extra(self): if hasattr(self, '_m_damage_extra'): return self._m_damage_extra self._m_damage_extra = self.base.damage_extra return getattr(self, '_m_damage_extra', None) @property def attack_tags(self): if hasattr(self, '_m_attack_tags'): return self._m_attack_tags self._m_attack_tags = self.base.attack_tags return getattr(self, '_m_attack_tags', None) @property def anim_event_names(self): if hasattr(self, '_m_anim_event_names'): return self._m_anim_event_names self._m_anim_event_names = self.base.anim_event_names return getattr(self, '_m_anim_event_names', None) @property def true_damage(self): if hasattr(self, '_m_true_damage'): return self._m_true_damage self._m_true_damage = self.base.true_damage return getattr(self, '_m_true_damage', None) @property def bonus_critical(self): if hasattr(self, '_m_bonus_critical'): return self._m_bonus_critical self._m_bonus_critical = self.base.bonus_critical return getattr(self, '_m_bonus_critical', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def defense_ignore_delta(self): if hasattr(self, '_m_defense_ignore_delta'): return self._m_defense_ignore_delta self._m_defense_ignore_delta = self.base.defense_ignore_delta return getattr(self, '_m_defense_ignore_delta', None) @property def element_type_modifier(self): if hasattr(self, '_m_element_type_modifier'): return self._m_element_type_modifier self._m_element_type_modifier = self.base.element_type_modifier return getattr(self, '_m_element_type_modifier', None) @property def has_field_max_count_actions(self): if hasattr(self, '_m_has_field_max_count_actions'): return self._m_has_field_max_count_actions self._m_has_field_max_count_actions = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_count_actions', None) @property def has_field_success_actions(self): if hasattr(self, '_m_has_field_success_actions'): return self._m_has_field_success_actions self._m_has_field_success_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_success_actions', None) @property def defense_ignore_ratio(self): if hasattr(self, '_m_defense_ignore_ratio'): return self._m_defense_ignore_ratio self._m_defense_ignore_ratio = self.base.defense_ignore_ratio return getattr(self, '_m_defense_ignore_ratio', None) @property def bonus_critical_hurt(self): if hasattr(self, '_m_bonus_critical_hurt'): return self._m_bonus_critical_hurt self._m_bonus_critical_hurt = self.base.bonus_critical_hurt return getattr(self, '_m_bonus_critical_hurt', None) @property def ignore_event_info(self): if hasattr(self, '_m_ignore_event_info'): return self._m_ignore_event_info self._m_ignore_event_info = self.base.ignore_event_info return getattr(self, '_m_ignore_event_info', None) @property def has_field_max_modify_count(self): if hasattr(self, '_m_has_field_max_modify_count'): return self._m_has_field_max_modify_count self._m_has_field_max_modify_count = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_modify_count', None) @property def has_field_count_predicates(self): if hasattr(self, '_m_has_field_count_predicates'): return self._m_has_field_count_predicates self._m_has_field_count_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_count_predicates', None) @property def attack_type(self): if hasattr(self, '_m_attack_type'): return self._m_attack_type self._m_attack_type = self.base.attack_type return getattr(self, '_m_attack_type', None) @property def damage_percentage(self): if hasattr(self, '_m_damage_percentage'): return self._m_damage_percentage self._m_damage_percentage = self.base.damage_percentage return getattr(self, '_m_damage_percentage', None) @property def has_field_is_ignore_attenuation(self): if hasattr(self, '_m_has_field_is_ignore_attenuation'): return self._m_has_field_is_ignore_attenuation self._m_has_field_is_ignore_attenuation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_ignore_attenuation', None) @property def damage_percentage_ratio(self): if hasattr(self, '_m_damage_percentage_ratio'): return self._m_damage_percentage_ratio self._m_damage_percentage_ratio = self.base.damage_percentage_ratio return getattr(self, '_m_damage_percentage_ratio', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigGuideDoActionByPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfArrayOfDispConfigBaseGuideLengthULengthU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) class ConfigHitScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_effect: self.default_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_surface_effect: self.surface_effect = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_default_effect(self): if hasattr(self, '_m_has_field_default_effect'): return self._m_has_field_default_effect self._m_has_field_default_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_effect', None) @property def has_field_surface_effect(self): if hasattr(self, '_m_has_field_surface_effect'): return self._m_has_field_surface_effect self._m_has_field_surface_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_surface_effect', None) class LookAtTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QteStepCameraPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldFurnitureExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSphereDetectDirection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SphereDetectDirection, self.data.value) return getattr(self, '_m_value', None) class EntityExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_pre = self._io.read_s1() if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_pre = self._io.read_s1() if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_pre = self._io.read_s1() if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_pre = self._io.read_s1() if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_camp_id', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) class SetOverrideMapValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_override_map_key: self.override_map_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_map_key(self): if hasattr(self, '_m_has_field_override_map_key'): return self._m_has_field_override_map_key self._m_has_field_override_map_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_override_map_key', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiFacingMoveSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFacingMoveData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFacingMoveData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class DictOfAuxTypesVlqBase128LeUConfigHomeFishpond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigHomeFishpond(self._io, self, self._root)) class WatcherTriggerConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_trigger_type: self.trigger_type = Output.EnumWatcherTriggerType(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_trigger_type(self): if hasattr(self, '_m_has_field_trigger_type'): return self._m_has_field_trigger_type self._m_has_field_trigger_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_trigger_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_list', None) class ConfigBornByTeleportToPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class MonsterRelationshipExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigGraphicsRequirementLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGraphicsRequirement(self._io, self, self._root)) class ArrayOfAnimatorFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AnimatorFloat(self._io, self, self._root)) class EnumDungeonType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfBoredMonsterConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BoredMonsterConfig(self._io, self, self._root)) class UgcMoveTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfConfigElementDecrateLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfConfigElementDecrateLengthU(self._io, self, self._root)) class DictOfAuxTypesStringArrayOfEnumTextLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfEnumTextLanguageTypeLengthU(self._io, self, self._root)) class ConfigHomeBlock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_block_id: self.block_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_persistent_furniture_list: self.persistent_furniture_list = Output.ArrayOfConfigHomeFurnitureLengthU(self._io, self, self._root) if self.has_field_deploy_furniure_list: self.deploy_furniure_list = Output.ArrayOfConfigHomeFurnitureLengthU(self._io, self, self._root) if self.has_field_furniture_suite_list: self.furniture_suite_list = Output.ArrayOfConfigHomeFurnitureSuiteLengthU(self._io, self, self._root) if self.has_field_deploy_animal_list: self.deploy_animal_list = Output.ArrayOfConfigHomeAnimalLengthU(self._io, self, self._root) if self.has_field_weekend_djinn_info_list: self.weekend_djinn_info_list = Output.ArrayOfConfigWeekendDjinnLengthU(self._io, self, self._root) @property def has_field_furniture_suite_list(self): if hasattr(self, '_m_has_field_furniture_suite_list'): return self._m_has_field_furniture_suite_list self._m_has_field_furniture_suite_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_furniture_suite_list', None) @property def has_field_deploy_furniure_list(self): if hasattr(self, '_m_has_field_deploy_furniure_list'): return self._m_has_field_deploy_furniure_list self._m_has_field_deploy_furniure_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_deploy_furniure_list', None) @property def has_field_persistent_furniture_list(self): if hasattr(self, '_m_has_field_persistent_furniture_list'): return self._m_has_field_persistent_furniture_list self._m_has_field_persistent_furniture_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_persistent_furniture_list', None) @property def has_field_block_id(self): if hasattr(self, '_m_has_field_block_id'): return self._m_has_field_block_id self._m_has_field_block_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_block_id', None) @property def has_field_deploy_animal_list(self): if hasattr(self, '_m_has_field_deploy_animal_list'): return self._m_has_field_deploy_animal_list self._m_has_field_deploy_animal_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_deploy_animal_list', None) @property def has_field_weekend_djinn_info_list(self): if hasattr(self, '_m_has_field_weekend_djinn_info_list'): return self._m_has_field_weekend_djinn_info_list self._m_has_field_weekend_djinn_info_list = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_weekend_djinn_info_list', None) class SectrSectorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialStatisticsListExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stat_name: self.stat_name = Output.EnumMistTrialStatisticType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_stat_name(self): if hasattr(self, '_m_has_field_stat_name'): return self._m_has_field_stat_name self._m_has_field_stat_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stat_name', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param', None) class ShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LoadingSituationExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_loading_situation_type: self.loading_situation_type = Output.EnumLoadingTipsSituationType(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_area1_id: self.area1_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_area_terrain_type: self.area_terrain_type = Output.EnumLoadingAreaType(self._io, self, self._root) if self.has_field_pic_path: self.pic_path = AuxTypes.String(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_pic_path(self): if hasattr(self, '_m_has_field_pic_path'): return self._m_has_field_pic_path self._m_has_field_pic_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pic_path', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_area_terrain_type(self): if hasattr(self, '_m_has_field_area_terrain_type'): return self._m_has_field_area_terrain_type self._m_has_field_area_terrain_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_area_terrain_type', None) @property def has_field_loading_situation_type(self): if hasattr(self, '_m_has_field_loading_situation_type'): return self._m_has_field_loading_situation_type self._m_has_field_loading_situation_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_loading_situation_type', None) @property def has_field_area1_id(self): if hasattr(self, '_m_has_field_area1_id'): return self._m_has_field_area1_id self._m_has_field_area1_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_area1_id', None) class WinterCampExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MapTagDataConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumAbilityCameraShotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AbilityCameraShotType, self.data.value) return getattr(self, '_m_value', None) class MultistageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigVodPlayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigVodPlayer(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLivePlayer(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ElementStateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMoveCategoryAi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoveCategoryAi, self.data.value) return getattr(self, '_m_value', None) class QuestExcelConfigUtils(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RejectEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UrgentHotFixMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_logic_id: self.logic_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_think_interval: self.think_interval = self._io.read_f4le() if self.has_field_action_list: self.action_list = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_logic_id(self): if hasattr(self, '_m_has_field_logic_id'): return self._m_has_field_logic_id self._m_has_field_logic_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_logic_id', None) @property def has_field_think_interval(self): if hasattr(self, '_m_has_field_think_interval'): return self._m_has_field_think_interval self._m_has_field_think_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_think_interval', None) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_action_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HandbookQuestGuideHintPicExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FleurFairBuffEnergyStatExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stat_param: self.stat_param = AuxTypes.String(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_stat_param(self): if hasattr(self, '_m_has_field_stat_param'): return self._m_has_field_stat_param self._m_has_field_stat_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stat_param', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class CustomLevelDungeonConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_json_path: self.json_path = AuxTypes.String(self._io, self, self._root) if self.has_field_map_prefab_path: self.map_prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_map_scene_pic_hash: self.map_scene_pic_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_scene_pic_hash: self.map_scene_pic_hash_pre = self._io.read_s1() if self.has_field_data_pic_hash: self.data_pic_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_data_pic_hash: self.data_pic_hash_pre = self._io.read_s1() if self.has_field_room_num: self.room_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_name_format: self.room_name_format = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_corridors: self.corridors = AuxTypes.String(self._io, self, self._root) if self.has_field_count_brick_list: self.count_brick_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_corridors(self): if hasattr(self, '_m_has_field_corridors'): return self._m_has_field_corridors self._m_has_field_corridors = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_corridors', None) @property def has_field_map_scene_pic_hash(self): if hasattr(self, '_m_has_field_map_scene_pic_hash'): return self._m_has_field_map_scene_pic_hash self._m_has_field_map_scene_pic_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_map_scene_pic_hash', None) @property def has_field_room_num(self): if hasattr(self, '_m_has_field_room_num'): return self._m_has_field_room_num self._m_has_field_room_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_room_num', None) @property def has_field_room_name_format(self): if hasattr(self, '_m_has_field_room_name_format'): return self._m_has_field_room_name_format self._m_has_field_room_name_format = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_room_name_format', None) @property def has_field_map_prefab_path(self): if hasattr(self, '_m_has_field_map_prefab_path'): return self._m_has_field_map_prefab_path self._m_has_field_map_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_map_prefab_path', None) @property def has_field_data_pic_hash(self): if hasattr(self, '_m_has_field_data_pic_hash'): return self._m_has_field_data_pic_hash self._m_has_field_data_pic_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_data_pic_hash', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_json_path', None) @property def has_field_count_brick_list(self): if hasattr(self, '_m_has_field_count_brick_list'): return self._m_has_field_count_brick_list self._m_has_field_count_brick_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_count_brick_list', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order', None) class ByTargetRaycastVisiable(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ArrayOfConfigHomeBlockLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeBlock(self._io, self, self._root)) class MonsterTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdRestrictionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_spawn_condition: self.spawn_condition = Output.EnumCrowdSpawnConditionType(self._io, self, self._root) if self.has_field_quest_res: self.quest_res = Output.ArrayOfConfigCrowdQuestRestrictionLengthU(self._io, self, self._root) if self.has_field_activity_res: self.activity_res = Output.ArrayOfConfigCrowdActivityRestrictionLengthU(self._io, self, self._root) if self.has_field_time_res: self.time_res = Output.ArrayOfConfigCrowdTimeRestrictionLengthU(self._io, self, self._root) if self.has_field_scene_tags: self.scene_tags = Output.ArrayOfConfigCrowdSceneTagRestrictionLengthU(self._io, self, self._root) @property def has_field_scene_tags(self): if hasattr(self, '_m_has_field_scene_tags'): return self._m_has_field_scene_tags self._m_has_field_scene_tags = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_scene_tags', None) @property def has_field_quest_res(self): if hasattr(self, '_m_has_field_quest_res'): return self._m_has_field_quest_res self._m_has_field_quest_res = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_res', None) @property def has_field_activity_res(self): if hasattr(self, '_m_has_field_activity_res'): return self._m_has_field_activity_res self._m_has_field_activity_res = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_activity_res', None) @property def has_field_time_res(self): if hasattr(self, '_m_has_field_time_res'): return self._m_has_field_time_res self._m_has_field_time_res = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_time_res', None) @property def has_field_spawn_condition(self): if hasattr(self, '_m_has_field_spawn_condition'): return self._m_has_field_spawn_condition self._m_has_field_spawn_condition = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_spawn_condition', None) class ConfigSkinInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effects: self.effects = Output.ConfigSkinFashionEffects(self._io, self, self._root) if self.has_field_gadgets: self.gadgets = Output.ConfigSkinFashionGadgets(self._io, self, self._root) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effects', None) @property def has_field_gadgets(self): if hasattr(self, '_m_has_field_gadgets'): return self._m_has_field_gadgets self._m_has_field_gadgets = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gadgets', None) class ConfigDynamicTalent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_talent_name: self.talent_name = AuxTypes.String(self._io, self, self._root) @property def has_field_talent_name(self): if hasattr(self, '_m_has_field_talent_name'): return self._m_has_field_talent_name self._m_has_field_talent_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_talent_name', None) class DialogExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_next_dialog: self.next_dialog = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_dialogs: self.next_dialogs = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_talk_show_type: self.talk_show_type = Output.EnumTalkShowType(self._io, self, self._root) if self.has_field_talk_role: self.talk_role = Output.TalkRole(self._io, self, self._root) if self.has_field_talk_content: self.talk_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_title: self.talk_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_role_name: self.talk_role_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_asset_path: self.talk_asset_path = AuxTypes.String(self._io, self, self._root) if self.has_field_talk_asset_path_alter: self.talk_asset_path_alter = AuxTypes.String(self._io, self, self._root) if self.has_field_talk_audio_name: self.talk_audio_name = AuxTypes.String(self._io, self, self._root) if self.has_field_action_before: self.action_before = AuxTypes.String(self._io, self, self._root) if self.has_field_action_while: self.action_while = AuxTypes.String(self._io, self, self._root) if self.has_field_action_after: self.action_after = AuxTypes.String(self._io, self, self._root) if self.has_field_show_duration: self.show_duration = self._io.read_f4le() if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_option_icon: self.option_icon = AuxTypes.String(self._io, self, self._root) @property def has_field_talk_content(self): if hasattr(self, '_m_has_field_talk_content'): return self._m_has_field_talk_content self._m_has_field_talk_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_talk_content', None) @property def has_field_action_after(self): if hasattr(self, '_m_has_field_action_after'): return self._m_has_field_action_after self._m_has_field_action_after = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_action_after', None) @property def has_field_talk_title(self): if hasattr(self, '_m_has_field_talk_title'): return self._m_has_field_talk_title self._m_has_field_talk_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_talk_title', None) @property def has_field_next_dialog(self): if hasattr(self, '_m_has_field_next_dialog'): return self._m_has_field_next_dialog self._m_has_field_next_dialog = False return getattr(self, '_m_has_field_next_dialog', None) @property def has_field_talk_role_name(self): if hasattr(self, '_m_has_field_talk_role_name'): return self._m_has_field_talk_role_name self._m_has_field_talk_role_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_talk_role_name', None) @property def has_field_next_dialogs(self): if hasattr(self, '_m_has_field_next_dialogs'): return self._m_has_field_next_dialogs self._m_has_field_next_dialogs = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_next_dialogs', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_talk_show_type(self): if hasattr(self, '_m_has_field_talk_show_type'): return self._m_has_field_talk_show_type self._m_has_field_talk_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_talk_show_type', None) @property def has_field_option_icon(self): if hasattr(self, '_m_has_field_option_icon'): return self._m_has_field_option_icon self._m_has_field_option_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_option_icon', None) @property def has_field_action_while(self): if hasattr(self, '_m_has_field_action_while'): return self._m_has_field_action_while self._m_has_field_action_while = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_action_while', None) @property def has_field_talk_asset_path_alter(self): if hasattr(self, '_m_has_field_talk_asset_path_alter'): return self._m_has_field_talk_asset_path_alter self._m_has_field_talk_asset_path_alter = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_talk_asset_path_alter', None) @property def has_field_show_duration(self): if hasattr(self, '_m_has_field_show_duration'): return self._m_has_field_show_duration self._m_has_field_show_duration = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_show_duration', None) @property def has_field_talk_asset_path(self): if hasattr(self, '_m_has_field_talk_asset_path'): return self._m_has_field_talk_asset_path self._m_has_field_talk_asset_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_talk_asset_path', None) @property def has_field_talk_audio_name(self): if hasattr(self, '_m_has_field_talk_audio_name'): return self._m_has_field_talk_audio_name self._m_has_field_talk_audio_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_talk_audio_name', None) @property def has_field_talk_role(self): if hasattr(self, '_m_has_field_talk_role'): return self._m_has_field_talk_role self._m_has_field_talk_role = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_talk_role', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_action_before(self): if hasattr(self, '_m_has_field_action_before'): return self._m_has_field_action_before self._m_has_field_action_before = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_action_before', None) class OptionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intee_icon_name: self.intee_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_guset_intee_button_show: self.guset_intee_button_show = self._io.read_u1() if self.has_field_cancel_online_match: self.cancel_online_match = self._io.read_u1() if self.has_field_disable_change_avatar_time: self.disable_change_avatar_time = self._io.read_f4le() @property def has_field_cancel_online_match(self): if hasattr(self, '_m_has_field_cancel_online_match'): return self._m_has_field_cancel_online_match self._m_has_field_cancel_online_match = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cancel_online_match', None) @property def has_field_guset_intee_button_show(self): if hasattr(self, '_m_has_field_guset_intee_button_show'): return self._m_has_field_guset_intee_button_show self._m_has_field_guset_intee_button_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_guset_intee_button_show', None) @property def has_field_intee_icon_name(self): if hasattr(self, '_m_has_field_intee_icon_name'): return self._m_has_field_intee_icon_name self._m_has_field_intee_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_intee_icon_name', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_content', None) @property def has_field_disable_change_avatar_time(self): if hasattr(self, '_m_has_field_disable_change_avatar_time'): return self._m_has_field_disable_change_avatar_time self._m_has_field_disable_change_avatar_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_disable_change_avatar_time', None) class LocalizationAssetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlayShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumControlPartForwardBy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ControlPartForwardBy, self.data.value) return getattr(self, '_m_value', None) class ConfigCameraShake(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_shake_type: self.shake_type = Output.EnumCameraShakeType(self._io, self, self._root) if self.has_field_shake_range: self.shake_range = self._io.read_f4le() if self.has_field_shake_time: self.shake_time = self._io.read_f4le() if self.has_field_shake_distance: self.shake_distance = self._io.read_f4le() if self.has_field_shake_dir: self.shake_dir = Output.Vector(self._io, self, self._root) if self.has_field_extension: self.extension = Output.ConfigCameraShakeExt(self._io, self, self._root) @property def has_field_shake_range(self): if hasattr(self, '_m_has_field_shake_range'): return self._m_has_field_shake_range self._m_has_field_shake_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shake_range', None) @property def has_field_shake_time(self): if hasattr(self, '_m_has_field_shake_time'): return self._m_has_field_shake_time self._m_has_field_shake_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_shake_time', None) @property def has_field_extension(self): if hasattr(self, '_m_has_field_extension'): return self._m_has_field_extension self._m_has_field_extension = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_extension', None) @property def has_field_shake_type(self): if hasattr(self, '_m_has_field_shake_type'): return self._m_has_field_shake_type self._m_has_field_shake_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shake_type', None) @property def has_field_shake_dir(self): if hasattr(self, '_m_has_field_shake_dir'): return self._m_has_field_shake_dir self._m_has_field_shake_dir = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_shake_dir', None) @property def has_field_shake_distance(self): if hasattr(self, '_m_has_field_shake_distance'): return self._m_has_field_shake_distance self._m_has_field_shake_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_shake_distance', None) class ConfigGuideNavigationCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_navigation_id: self.navigation_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_navigation_type: self.navigation_type = Output.EnumGuideNavigationType(self._io, self, self._root) if self.has_field_check_type: self.check_type = Output.EnumGuideNavigationCheckType(self._io, self, self._root) if self.has_field_only_check_change: self.only_check_change = self._io.read_u1() @property def has_field_only_check_change(self): if hasattr(self, '_m_has_field_only_check_change'): return self._m_has_field_only_check_change self._m_has_field_only_check_change = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_only_check_change', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_check_type(self): if hasattr(self, '_m_has_field_check_type'): return self._m_has_field_check_type self._m_has_field_check_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_check_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def has_field_navigation_type(self): if hasattr(self, '_m_has_field_navigation_type'): return self._m_has_field_navigation_type self._m_has_field_navigation_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_navigation_type', None) @property def has_field_navigation_id(self): if hasattr(self, '_m_has_field_navigation_id'): return self._m_has_field_navigation_id self._m_has_field_navigation_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_navigation_id', None) class EffigyRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDoActionByDamageReceivedParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DoActionByDamageReceivedParamType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumEntityTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumEntityType(self._io, self, self._root)) class ReferenceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumBeFollowState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BeFollowState, self.data.value) return getattr(self, '_m_value', None) class ChangeTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_add: self.is_add = self._io.read_u1() if self.has_field_tag: self.tag = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_tag', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_is_add(self): if hasattr(self, '_m_has_field_is_add'): return self._m_has_field_is_add self._m_has_field_is_add = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_add', None) class AuxObjectEntryFullInspector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DataEntityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReminderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speaker: self.speaker = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_delay: self.delay = self._io.read_f4le() if self.has_field_show_time: self.show_time = self._io.read_f4le() if self.has_field_next_reminder_id: self.next_reminder_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sound_effect: self.sound_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_style: self.style = Output.EnumReminderStyleType(self._io, self, self._root) if self.has_field_has_audio: self.has_audio = self._io.read_u1() @property def has_field_next_reminder_id(self): if hasattr(self, '_m_has_field_next_reminder_id'): return self._m_has_field_next_reminder_id self._m_has_field_next_reminder_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_next_reminder_id', None) @property def has_field_show_time(self): if hasattr(self, '_m_has_field_show_time'): return self._m_has_field_show_time self._m_has_field_show_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_show_time', None) @property def has_field_speaker(self): if hasattr(self, '_m_has_field_speaker'): return self._m_has_field_speaker self._m_has_field_speaker = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_speaker', None) @property def has_field_sound_effect(self): if hasattr(self, '_m_has_field_sound_effect'): return self._m_has_field_sound_effect self._m_has_field_sound_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_sound_effect', None) @property def has_field_has_audio(self): if hasattr(self, '_m_has_field_has_audio'): return self._m_has_field_has_audio self._m_has_field_has_audio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_has_audio', None) @property def has_field_delay(self): if hasattr(self, '_m_has_field_delay'): return self._m_has_field_delay self._m_has_field_delay = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_delay', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_style(self): if hasattr(self, '_m_has_field_style'): return self._m_has_field_style self._m_has_field_style = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_style', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content', None) class BanGroupTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumStateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StateType, self.data.value) return getattr(self, '_m_value', None) class ConfigAnimatorEventPatternFullInspector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigRecordActorBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigRecordActorBase(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigRecordEntity(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigRecordEffect(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigPostprocessEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_use_half_shadows: self.use_half_shadows = self._io.read_u1() if self.has_field_use_shadow_cache: self.use_shadow_cache = self._io.read_u1() if self.has_field_checkboard_type: self.checkboard_type = Output.EnumCheckboardType(self._io, self, self._root) if self.has_field_ao_mode: self.ao_mode = Output.EnumSsaoMode(self._io, self, self._root) if self.has_field_enable_motion_blur: self.enable_motion_blur = self._io.read_u1() if self.has_field_motion_blur_quality: self.motion_blur_quality = Output.EnumMotionBlurQuality(self._io, self, self._root) if self.has_field_fsr_scale: self.fsr_scale = self._io.read_f4le() if self.has_field_avatar_motion_vector_strategy: self.avatar_motion_vector_strategy = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_ao_mode(self): if hasattr(self, '_m_has_field_ao_mode'): return self._m_has_field_ao_mode self._m_has_field_ao_mode = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ao_mode', None) @property def has_field_motion_blur_quality(self): if hasattr(self, '_m_has_field_motion_blur_quality'): return self._m_has_field_motion_blur_quality self._m_has_field_motion_blur_quality = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_motion_blur_quality', None) @property def has_field_checkboard_type(self): if hasattr(self, '_m_has_field_checkboard_type'): return self._m_has_field_checkboard_type self._m_has_field_checkboard_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_checkboard_type', None) @property def has_field_enable_motion_blur(self): if hasattr(self, '_m_has_field_enable_motion_blur'): return self._m_has_field_enable_motion_blur self._m_has_field_enable_motion_blur = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_enable_motion_blur', None) @property def has_field_use_half_shadows(self): if hasattr(self, '_m_has_field_use_half_shadows'): return self._m_has_field_use_half_shadows self._m_has_field_use_half_shadows = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_half_shadows', None) @property def has_field_fsr_scale(self): if hasattr(self, '_m_has_field_fsr_scale'): return self._m_has_field_fsr_scale self._m_has_field_fsr_scale = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_fsr_scale', None) @property def has_field_avatar_motion_vector_strategy(self): if hasattr(self, '_m_has_field_avatar_motion_vector_strategy'): return self._m_has_field_avatar_motion_vector_strategy self._m_has_field_avatar_motion_vector_strategy = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_avatar_motion_vector_strategy', None) @property def has_field_use_shadow_cache(self): if hasattr(self, '_m_has_field_use_shadow_cache'): return self._m_has_field_use_shadow_cache self._m_has_field_use_shadow_cache = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_shadow_cache', None) class DirectionTarDistanceScatter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_distance: self.max_distance = self._io.read_f4le() if self.has_field_max_scatter_angle: self.max_scatter_angle = self._io.read_f4le() if self.has_field_center_rote: self.center_rote = self._io.read_f4le() if self.has_field_random_rote: self.random_rote = self._io.read_f4le() @property def has_field_max_distance(self): if hasattr(self, '_m_has_field_max_distance'): return self._m_has_field_max_distance self._m_has_field_max_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_distance', None) @property def has_field_max_scatter_angle(self): if hasattr(self, '_m_has_field_max_scatter_angle'): return self._m_has_field_max_scatter_angle self._m_has_field_max_scatter_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_scatter_angle', None) @property def has_field_center_rote(self): if hasattr(self, '_m_has_field_center_rote'): return self._m_has_field_center_rote self._m_has_field_center_rote = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_center_rote', None) @property def has_field_random_rote(self): if hasattr(self, '_m_has_field_random_rote'): return self._m_has_field_random_rote self._m_has_field_random_rote = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_rote', None) class ConfigEffectPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effect_paths: self.effect_paths = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_sub_emitters: self.sub_emitters = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_effect_paths(self): if hasattr(self, '_m_has_field_effect_paths'): return self._m_has_field_effect_paths self._m_has_field_effect_paths = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_paths', None) @property def has_field_sub_emitters(self): if hasattr(self, '_m_has_field_sub_emitters'): return self._m_has_field_sub_emitters self._m_has_field_sub_emitters = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sub_emitters', None) class ConfigBanSelfGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_ban: self.is_ban = self._io.read_u1() @property def has_field_is_ban(self): if hasattr(self, '_m_has_field_is_ban'): return self._m_has_field_is_ban self._m_has_field_is_ban = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_ban', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(AuxTypes.VlqBase128LeS(self._io, self, self._root)) class EnumDiePatternSwitchMixinPriority(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DiePatternSwitchMixinPriority, self.data.value) return getattr(self, '_m_value', None) class OnAvatarUseSkillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_on_trigger_normal_attack: self.on_trigger_normal_attack = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_trigger_skill: self.on_trigger_skill = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_on_trigger_ultimate_skill: self.on_trigger_ultimate_skill = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_use_skill_start: self.use_skill_start = self._io.read_u1() if self.has_field_clear_skill_id_delay: self.clear_skill_id_delay = self._io.read_f4le() @property def has_field_on_trigger_ultimate_skill(self): if hasattr(self, '_m_has_field_on_trigger_ultimate_skill'): return self._m_has_field_on_trigger_ultimate_skill self._m_has_field_on_trigger_ultimate_skill = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_trigger_ultimate_skill', None) @property def has_field_on_trigger_normal_attack(self): if hasattr(self, '_m_has_field_on_trigger_normal_attack'): return self._m_has_field_on_trigger_normal_attack self._m_has_field_on_trigger_normal_attack = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_trigger_normal_attack', None) @property def has_field_use_skill_start(self): if hasattr(self, '_m_has_field_use_skill_start'): return self._m_has_field_use_skill_start self._m_has_field_use_skill_start = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_use_skill_start', None) @property def has_field_clear_skill_id_delay(self): if hasattr(self, '_m_has_field_clear_skill_id_delay'): return self._m_has_field_clear_skill_id_delay self._m_has_field_clear_skill_id_delay = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_clear_skill_id_delay', None) @property def has_field_on_trigger_skill(self): if hasattr(self, '_m_has_field_on_trigger_skill'): return self._m_has_field_on_trigger_skill self._m_has_field_on_trigger_skill = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_trigger_skill', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumCheckboardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CheckboardType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigSceneArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigSceneArea(self._io, self, self._root)) class EntityColliderTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEndureType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EndureType, self.data.value) return getattr(self, '_m_value', None) class ExtraAbilityStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigCustomLevelRoomSettingLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCustomLevelRoomSetting(self._io, self, self._root)) class AsterMissionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mission_id: self.mission_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_phase: self.phase = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trans_point_id: self.trans_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trace_point: self.trace_point = AuxTypes.String(self._io, self, self._root) if self.has_field_perfab_path_hash: self.perfab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfab_path_hash: self.perfab_path_hash_pre = self._io.read_s1() @property def has_field_phase(self): if hasattr(self, '_m_has_field_phase'): return self._m_has_field_phase self._m_has_field_phase = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_phase', None) @property def has_field_mission_id(self): if hasattr(self, '_m_has_field_mission_id'): return self._m_has_field_mission_id self._m_has_field_mission_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mission_id', None) @property def has_field_trace_point(self): if hasattr(self, '_m_has_field_trace_point'): return self._m_has_field_trace_point self._m_has_field_trace_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_trace_point', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_trans_point_id(self): if hasattr(self, '_m_has_field_trans_point_id'): return self._m_has_field_trans_point_id self._m_has_field_trans_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_trans_point_id', None) @property def has_field_perfab_path_hash(self): if hasattr(self, '_m_has_field_perfab_path_hash'): return self._m_has_field_perfab_path_hash self._m_has_field_perfab_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_perfab_path_hash', None) class EnumCardProductType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CardProductType, self.data.value) return getattr(self, '_m_value', None) class ChessCardEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityMistTrialLevelDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_title: self.level_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_preview_id_list: self.monster_preview_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_key_monster_preview_id_list: self.key_monster_preview_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_mission_watcher_list: self.challenge_mission_watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_statistics_id_list: self.statistics_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bg_icon_hash: self.bg_icon_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bg_icon_hash: self.bg_icon_hash_pre = self._io.read_s1() if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_factor_id_list: self.dungeon_factor_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_fail_tips: self.fail_tips = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_trial_avatar_id_list: self.trial_avatar_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_server_global_value_key: self.server_global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_floor_level_list: self.floor_level_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_battle_statistics_data: self.battle_statistics_data = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_key_monster_preview_id_list(self): if hasattr(self, '_m_has_field_key_monster_preview_id_list'): return self._m_has_field_key_monster_preview_id_list self._m_has_field_key_monster_preview_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_key_monster_preview_id_list', None) @property def has_field_monster_preview_id_list(self): if hasattr(self, '_m_has_field_monster_preview_id_list'): return self._m_has_field_monster_preview_id_list self._m_has_field_monster_preview_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_monster_preview_id_list', None) @property def has_field_fail_tips(self): if hasattr(self, '_m_has_field_fail_tips'): return self._m_has_field_fail_tips self._m_has_field_fail_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_fail_tips', None) @property def has_field_level_title(self): if hasattr(self, '_m_has_field_level_title'): return self._m_has_field_level_title self._m_has_field_level_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_title', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_challenge_mission_watcher_list(self): if hasattr(self, '_m_has_field_challenge_mission_watcher_list'): return self._m_has_field_challenge_mission_watcher_list self._m_has_field_challenge_mission_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_challenge_mission_watcher_list', None) @property def has_field_statistics_id_list(self): if hasattr(self, '_m_has_field_statistics_id_list'): return self._m_has_field_statistics_id_list self._m_has_field_statistics_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_statistics_id_list', None) @property def has_field_trial_avatar_id_list(self): if hasattr(self, '_m_has_field_trial_avatar_id_list'): return self._m_has_field_trial_avatar_id_list self._m_has_field_trial_avatar_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_trial_avatar_id_list', None) @property def has_field_server_global_value_key(self): if hasattr(self, '_m_has_field_server_global_value_key'): return self._m_has_field_server_global_value_key self._m_has_field_server_global_value_key = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_server_global_value_key', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_level_desc', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_floor_level_list(self): if hasattr(self, '_m_has_field_floor_level_list'): return self._m_has_field_floor_level_list self._m_has_field_floor_level_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_floor_level_list', None) @property def has_field_dungeon_factor_id_list(self): if hasattr(self, '_m_has_field_dungeon_factor_id_list'): return self._m_has_field_dungeon_factor_id_list self._m_has_field_dungeon_factor_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_dungeon_factor_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_battle_statistics_data(self): if hasattr(self, '_m_has_field_battle_statistics_data'): return self._m_has_field_battle_statistics_data self._m_has_field_battle_statistics_data = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_battle_statistics_data', None) @property def has_field_bg_icon_hash(self): if hasattr(self, '_m_has_field_bg_icon_hash'): return self._m_has_field_bg_icon_hash self._m_has_field_bg_icon_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_bg_icon_hash', None) class ConfigBaseWidget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_consume_material: self.is_consume_material = self._io.read_u1() if self.has_field_is_equipable: self.is_equipable = self._io.read_u1() if self.has_field_cool_down: self.cool_down = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cool_down_on_fail: self.cool_down_on_fail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cool_down_group: self.cool_down_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_cd_under_time_scale: self.is_cd_under_time_scale = self._io.read_u1() if self.has_field_is_allowed_in_dungeon: self.is_allowed_in_dungeon = self._io.read_u1() if self.has_field_is_allowed_in_room: self.is_allowed_in_room = self._io.read_u1() if self.has_field_ornaments_type: self.ornaments_type = Output.EnumOrnamentsType(self._io, self, self._root) @property def has_field_cool_down_group(self): if hasattr(self, '_m_has_field_cool_down_group'): return self._m_has_field_cool_down_group self._m_has_field_cool_down_group = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_cool_down_group', None) @property def has_field_is_cd_under_time_scale(self): if hasattr(self, '_m_has_field_is_cd_under_time_scale'): return self._m_has_field_is_cd_under_time_scale self._m_has_field_is_cd_under_time_scale = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_is_cd_under_time_scale', None) @property def has_field_is_equipable(self): if hasattr(self, '_m_has_field_is_equipable'): return self._m_has_field_is_equipable self._m_has_field_is_equipable = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_is_equipable', None) @property def has_field_is_allowed_in_dungeon(self): if hasattr(self, '_m_has_field_is_allowed_in_dungeon'): return self._m_has_field_is_allowed_in_dungeon self._m_has_field_is_allowed_in_dungeon = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_is_allowed_in_dungeon', None) @property def has_field_cool_down(self): if hasattr(self, '_m_has_field_cool_down'): return self._m_has_field_cool_down self._m_has_field_cool_down = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_cool_down', None) @property def has_field_is_allowed_in_room(self): if hasattr(self, '_m_has_field_is_allowed_in_room'): return self._m_has_field_is_allowed_in_room self._m_has_field_is_allowed_in_room = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_is_allowed_in_room', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_material_id', None) @property def has_field_ornaments_type(self): if hasattr(self, '_m_has_field_ornaments_type'): return self._m_has_field_ornaments_type self._m_has_field_ornaments_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_ornaments_type', None) @property def has_field_cool_down_on_fail(self): if hasattr(self, '_m_has_field_cool_down_on_fail'): return self._m_has_field_cool_down_on_fail self._m_has_field_cool_down_on_fail = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_cool_down_on_fail', None) @property def has_field_is_consume_material(self): if hasattr(self, '_m_has_field_is_consume_material'): return self._m_has_field_is_consume_material self._m_has_field_is_consume_material = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_is_consume_material', None) class MistTrialStatisticTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WinterCampSnowmanDetailExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigQteStepNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_start_trigger: self.start_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) if self.has_field_components: self.components = Output.ArrayOfDispConfigQteStepBaseComponentLengthU(self._io, self, self._root) if self.has_field_success_trigger: self.success_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) if self.has_field_fail_trigger: self.fail_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) @property def has_field_start_trigger(self): if hasattr(self, '_m_has_field_start_trigger'): return self._m_has_field_start_trigger self._m_has_field_start_trigger = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start_trigger', None) @property def has_field_components(self): if hasattr(self, '_m_has_field_components'): return self._m_has_field_components self._m_has_field_components = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_components', None) @property def has_field_success_trigger(self): if hasattr(self, '_m_has_field_success_trigger'): return self._m_has_field_success_trigger self._m_has_field_success_trigger = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_success_trigger', None) @property def has_field_fail_trigger(self): if hasattr(self, '_m_has_field_fail_trigger'): return self._m_has_field_fail_trigger self._m_has_field_fail_trigger = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fail_trigger', None) class ActivityGearGadgetGearExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumBattlePassScheduleRewardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BattlePassScheduleRewardType, self.data.value) return getattr(self, '_m_value', None) class ConfigJudgeAvatarFaceTarget2d(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group_entity_list: self.group_entity_list = Output.ArrayOfConfigJudgeGroupEntityLengthU(self._io, self, self._root) if self.has_field_custom_direction: self.custom_direction = Output.Vector(self._io, self, self._root) @property def has_field_group_entity_list(self): if hasattr(self, '_m_has_field_group_entity_list'): return self._m_has_field_group_entity_list self._m_has_field_group_entity_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_entity_list', None) @property def has_field_custom_direction(self): if hasattr(self, '_m_has_field_custom_direction'): return self._m_has_field_custom_direction self._m_has_field_custom_direction = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_custom_direction', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class ConfigGuideHasAvatarCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumGuideHasAvatarType(self._io, self, self._root) if self.has_field_con_type: self.con_type = Output.EnumGuideHasAvatarConType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_con_type(self): if hasattr(self, '_m_has_field_con_type'): return self._m_has_field_con_type self._m_has_field_con_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_con_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class SummerTimeV2dungeonStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prev_dungeon_id: self.prev_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cycle_dungeon_id: self.cycle_dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_id_list: self.quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entrance_name: self.entrance_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_name: self.quest_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_dungeon_id1: self.story_dungeon_id1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_dungeon_id2: self.story_dungeon_id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_dungeon_id3: self.story_dungeon_id3 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_exhibition_id_list: self.dungeon_exhibition_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_card_id_list: self.dungeon_card_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_story_start_cond_id: self.story_start_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_start_cond_id: self.dungeon_start_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_reward_limit: self.dungeon_reward_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_entry_name: self.dungeon_entry_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_dungeon_card_id_list(self): if hasattr(self, '_m_has_field_dungeon_card_id_list'): return self._m_has_field_dungeon_card_id_list self._m_has_field_dungeon_card_id_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_card_id_list', None) @property def has_field_story_dungeon_id3(self): if hasattr(self, '_m_has_field_story_dungeon_id3'): return self._m_has_field_story_dungeon_id3 self._m_has_field_story_dungeon_id3 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_story_dungeon_id3', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_entrance_name(self): if hasattr(self, '_m_has_field_entrance_name'): return self._m_has_field_entrance_name self._m_has_field_entrance_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_entrance_name', None) @property def has_field_dungeon_start_cond_id(self): if hasattr(self, '_m_has_field_dungeon_start_cond_id'): return self._m_has_field_dungeon_start_cond_id self._m_has_field_dungeon_start_cond_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_start_cond_id', None) @property def has_field_story_dungeon_id2(self): if hasattr(self, '_m_has_field_story_dungeon_id2'): return self._m_has_field_story_dungeon_id2 self._m_has_field_story_dungeon_id2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_story_dungeon_id2', None) @property def has_field_story_start_cond_id(self): if hasattr(self, '_m_has_field_story_start_cond_id'): return self._m_has_field_story_start_cond_id self._m_has_field_story_start_cond_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_story_start_cond_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_prev_dungeon_id(self): if hasattr(self, '_m_has_field_prev_dungeon_id'): return self._m_has_field_prev_dungeon_id self._m_has_field_prev_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_prev_dungeon_id', None) @property def has_field_dungeon_entry_name(self): if hasattr(self, '_m_has_field_dungeon_entry_name'): return self._m_has_field_dungeon_entry_name self._m_has_field_dungeon_entry_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_dungeon_entry_name', None) @property def has_field_quest_id_list(self): if hasattr(self, '_m_has_field_quest_id_list'): return self._m_has_field_quest_id_list self._m_has_field_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_id_list', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_cycle_dungeon_id(self): if hasattr(self, '_m_has_field_cycle_dungeon_id'): return self._m_has_field_cycle_dungeon_id self._m_has_field_cycle_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cycle_dungeon_id', None) @property def has_field_dungeon_reward_limit(self): if hasattr(self, '_m_has_field_dungeon_reward_limit'): return self._m_has_field_dungeon_reward_limit self._m_has_field_dungeon_reward_limit = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_reward_limit', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_story_dungeon_id1(self): if hasattr(self, '_m_has_field_story_dungeon_id1'): return self._m_has_field_story_dungeon_id1 self._m_has_field_story_dungeon_id1 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_story_dungeon_id1', None) @property def has_field_dungeon_exhibition_id_list(self): if hasattr(self, '_m_has_field_dungeon_exhibition_id_list'): return self._m_has_field_dungeon_exhibition_id_list self._m_has_field_dungeon_exhibition_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_dungeon_exhibition_id_list', None) @property def has_field_quest_name(self): if hasattr(self, '_m_has_field_quest_name'): return self._m_has_field_quest_name self._m_has_field_quest_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_quest_name', None) class RegionShapeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfBoolItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_value: self.override_value = self._io.read_u1() @property def has_field_override_value(self): if hasattr(self, '_m_has_field_override_value'): return self._m_has_field_override_value self._m_has_field_override_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_value', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) class CreaterBornTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShowMessageAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_txt_map_str: self.txt_map_str = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_txt_map_str(self): if hasattr(self, '_m_has_field_txt_map_str'): return self._m_has_field_txt_map_str self._m_has_field_txt_map_str = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_txt_map_str', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfOpenStateCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.OpenStateCond(self._io, self, self._root)) class EnumElemBallTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ElemBallTriggerType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfMpCrucibleRewardConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MpCrucibleRewardConfig(self._io, self, self._root)) class EnumNavType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NavType, self.data.value) return getattr(self, '_m_value', None) class LanV2fireworksOverallDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAnimatorFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_normalize_start: self.normalize_start = self._io.read_f4le() if self.has_field_normalize_end: self.normalize_end = self._io.read_f4le() if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_normalize_start(self): if hasattr(self, '_m_has_field_normalize_start'): return self._m_has_field_normalize_start self._m_has_field_normalize_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_normalize_start', None) @property def has_field_normalize_end(self): if hasattr(self, '_m_has_field_normalize_end'): return self._m_has_field_normalize_end self._m_has_field_normalize_end = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_normalize_end', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_value', None) class WatcherTriggerTraceBackTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelLayout(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_blocks: self.blocks = Output.ArrayOfConfigLevelBlockLengthU(self._io, self, self._root) @property def has_field_blocks(self): if hasattr(self, '_m_has_field_blocks'): return self._m_has_field_blocks self._m_has_field_blocks = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_blocks', None) class EnumSceneAreaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneAreaType, self.data.value) return getattr(self, '_m_value', None) class ElementOuterGlowEffectMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ProudSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UpdateUidValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumItemLimitConstValueType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemLimitConstValueType, self.data.value) return getattr(self, '_m_value', None) class ConfigPredicateByPlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_start: self.is_start = self._io.read_u1() @property def has_field_is_start(self): if hasattr(self, '_m_has_field_is_start'): return self._m_has_field_is_start self._m_has_field_is_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_start', None) class EnumCenterPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CenterPosType, self.data.value) return getattr(self, '_m_value', None) class MixinTargettingComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachModifierToGlobalValueMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_value_target: self.global_value_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_action_queues: self.action_queues = Output.ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(self._io, self, self._root) if self.has_field_remove_applied_modifier: self.remove_applied_modifier = self._io.read_u1() if self.has_field_remove_applied_modifier_target_disappear: self.remove_applied_modifier_target_disappear = self._io.read_u1() if self.has_field_remove_applied_modifier_clear_global_value: self.remove_applied_modifier_clear_global_value = self._io.read_u1() if self.has_field_remove_modifier_by_attach: self.remove_modifier_by_attach = self._io.read_u1() if self.has_field_target_register_type: self.target_register_type = Output.EnumTargetRegisterType(self._io, self, self._root) if self.has_field_not_remove_modifier_when_entity_not_sync: self.not_remove_modifier_when_entity_not_sync = self._io.read_u1() @property def has_field_action_queues(self): if hasattr(self, '_m_has_field_action_queues'): return self._m_has_field_action_queues self._m_has_field_action_queues = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_action_queues', None) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_remove_applied_modifier_target_disappear(self): if hasattr(self, '_m_has_field_remove_applied_modifier_target_disappear'): return self._m_has_field_remove_applied_modifier_target_disappear self._m_has_field_remove_applied_modifier_target_disappear = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_remove_applied_modifier_target_disappear', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_global_value_target(self): if hasattr(self, '_m_has_field_global_value_target'): return self._m_has_field_global_value_target self._m_has_field_global_value_target = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_global_value_target', None) @property def has_field_not_remove_modifier_when_entity_not_sync(self): if hasattr(self, '_m_has_field_not_remove_modifier_when_entity_not_sync'): return self._m_has_field_not_remove_modifier_when_entity_not_sync self._m_has_field_not_remove_modifier_when_entity_not_sync = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_not_remove_modifier_when_entity_not_sync', None) @property def has_field_target_register_type(self): if hasattr(self, '_m_has_field_target_register_type'): return self._m_has_field_target_register_type self._m_has_field_target_register_type = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_target_register_type', None) @property def has_field_remove_modifier_by_attach(self): if hasattr(self, '_m_has_field_remove_modifier_by_attach'): return self._m_has_field_remove_modifier_by_attach self._m_has_field_remove_modifier_by_attach = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_remove_modifier_by_attach', None) @property def has_field_remove_applied_modifier_clear_global_value(self): if hasattr(self, '_m_has_field_remove_applied_modifier_clear_global_value'): return self._m_has_field_remove_applied_modifier_clear_global_value self._m_has_field_remove_applied_modifier_clear_global_value = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_remove_applied_modifier_clear_global_value', None) @property def has_field_remove_applied_modifier(self): if hasattr(self, '_m_has_field_remove_applied_modifier'): return self._m_has_field_remove_applied_modifier self._m_has_field_remove_applied_modifier = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_remove_applied_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class DispConfigAudioEventCullingRuleBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigRuleLimitFrame(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigRuleCullingEvent(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigRuleCullingDistance(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigRuleLimitFrameGlobal(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigRuleCullingEventNameContain(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigRuleWaitDistance(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigGuideMultiSinglePlayerCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_in: self.is_in = self._io.read_u1() @property def has_field_is_in(self): if hasattr(self, '_m_has_field_is_in'): return self._m_has_field_is_in self._m_has_field_is_in = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_in', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnterCameraLock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trans_name: self.trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_cfg_path: self.cfg_path = AuxTypes.String(self._io, self, self._root) @property def has_field_cfg_path(self): if hasattr(self, '_m_has_field_cfg_path'): return self._m_has_field_cfg_path self._m_has_field_cfg_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cfg_path', None) @property def has_field_trans_name(self): if hasattr(self, '_m_has_field_trans_name'): return self._m_has_field_trans_name self._m_has_field_trans_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trans_name', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfQuestContentExLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestContentEx(self._io, self, self._root)) class ByHitEnBreak(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_en_break: self.en_break = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_en_break(self): if hasattr(self, '_m_has_field_en_break'): return self._m_has_field_en_break self._m_has_field_en_break = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_en_break', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class LanV2projectionStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_day', None) class ArrayOfConfigCustomNodeInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCustomNodeInfo(self._io, self, self._root)) class ConfigUiTriggerInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_context_name', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfAuxTypesDynamicFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(AuxTypes.DynamicFloat(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeUEnumPositionModifyState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUEnumPositionModifyState(self._io, self, self._root)) class DigGroupLinkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage: self.stage = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_bundle_id: self.group_link_bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_bundle_id2: self.group_link_bundle_id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_change_cond: self.group_link_change_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_name: self.area_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_background: self.background = AuxTypes.String(self._io, self, self._root) @property def has_field_background(self): if hasattr(self, '_m_has_field_background'): return self._m_has_field_background self._m_has_field_background = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_background', None) @property def has_field_group_link_bundle_id(self): if hasattr(self, '_m_has_field_group_link_bundle_id'): return self._m_has_field_group_link_bundle_id self._m_has_field_group_link_bundle_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_link_bundle_id', None) @property def has_field_group_link_bundle_id2(self): if hasattr(self, '_m_has_field_group_link_bundle_id2'): return self._m_has_field_group_link_bundle_id2 self._m_has_field_group_link_bundle_id2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_link_bundle_id2', None) @property def has_field_stage(self): if hasattr(self, '_m_has_field_stage'): return self._m_has_field_stage self._m_has_field_stage = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_area_name(self): if hasattr(self, '_m_has_field_area_name'): return self._m_has_field_area_name self._m_has_field_area_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_area_name', None) @property def has_field_group_link_change_cond(self): if hasattr(self, '_m_has_field_group_link_change_cond'): return self._m_has_field_group_link_change_cond self._m_has_field_group_link_change_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_group_link_change_cond', None) class ArrayOfCaptureTagConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CaptureTagConfig(self._io, self, self._root)) class Int8NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class DisplayItemExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideContextListTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfGradeItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOptionArrayInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_option_array: self.item_option_array = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_item_option_array(self): if hasattr(self, '_m_has_field_item_option_array'): return self._m_has_field_item_option_array self._m_has_field_item_option_array = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_option_array', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) class ByCurTeamWeaponTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class AvatarCameraParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_param: self.camera_param = Output.ConfigStateCameraParam(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_camera_param(self): if hasattr(self, '_m_has_field_camera_param'): return self._m_has_field_camera_param self._m_has_field_camera_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_param', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class AttachModifierToSelfGlobalValueAndTalkStateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.AttachModifierToSelfGlobalValueMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gv_in_talk: self.gv_in_talk = AuxTypes.DynamicFloat(self._io, self, self._root) @property def global_value_target(self): if hasattr(self, '_m_global_value_target'): return self._m_global_value_target self._m_global_value_target = self.base.global_value_target return getattr(self, '_m_global_value_target', None) @property def global_value_key(self): if hasattr(self, '_m_global_value_key'): return self._m_global_value_key self._m_global_value_key = self.base.global_value_key return getattr(self, '_m_global_value_key', None) @property def default_global_value_on_create(self): if hasattr(self, '_m_default_global_value_on_create'): return self._m_default_global_value_on_create self._m_default_global_value_on_create = self.base.default_global_value_on_create return getattr(self, '_m_default_global_value_on_create', None) @property def action_queues(self): if hasattr(self, '_m_action_queues'): return self._m_action_queues self._m_action_queues = self.base.action_queues return getattr(self, '_m_action_queues', None) @property def value_steps(self): if hasattr(self, '_m_value_steps'): return self._m_value_steps self._m_value_steps = self.base.value_steps return getattr(self, '_m_value_steps', None) @property def remove_applied_modifier(self): if hasattr(self, '_m_remove_applied_modifier'): return self._m_remove_applied_modifier self._m_remove_applied_modifier = self.base.remove_applied_modifier return getattr(self, '_m_remove_applied_modifier', None) @property def modifier_name_steps(self): if hasattr(self, '_m_modifier_name_steps'): return self._m_modifier_name_steps self._m_modifier_name_steps = self.base.modifier_name_steps return getattr(self, '_m_modifier_name_steps', None) @property def has_field_gv_in_talk(self): if hasattr(self, '_m_has_field_gv_in_talk'): return self._m_has_field_gv_in_talk self._m_has_field_gv_in_talk = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gv_in_talk', None) @property def add_action(self): if hasattr(self, '_m_add_action'): return self._m_add_action self._m_add_action = self.base.add_action return getattr(self, '_m_add_action', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfAnimatorIntLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AnimatorInt(self._io, self, self._root)) class EnumPlayModeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlayModeType, self.data.value) return getattr(self, '_m_value', None) class SetSurroundAnchor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_point: self.set_point = self._io.read_u1() if self.has_field_action_point_type: self.action_point_type = Output.EnumActionPointType(self._io, self, self._root) if self.has_field_action_point_id: self.action_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_action_point_type(self): if hasattr(self, '_m_has_field_action_point_type'): return self._m_has_field_action_point_type self._m_has_field_action_point_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_point_type', None) @property def has_field_set_point(self): if hasattr(self, '_m_has_field_set_point'): return self._m_has_field_set_point self._m_has_field_set_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_point', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_action_point_id(self): if hasattr(self, '_m_has_field_action_point_id'): return self._m_has_field_action_point_id self._m_has_field_action_point_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_action_point_id', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumCurtainType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CurtainType, self.data.value) return getattr(self, '_m_value', None) class ElemBallTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByAvatarWeaponType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weapon_types: self.weapon_types = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_weapon_types(self): if hasattr(self, '_m_has_field_weapon_types'): return self._m_has_field_weapon_types self._m_has_field_weapon_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weapon_types', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActivityIslandPartyStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigAiSkillType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigAiSkillType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiSpacialAdjustData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_y_low: self.y_low = self._io.read_f4le() if self.has_field_y_high: self.y_high = self._io.read_f4le() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_y_low(self): if hasattr(self, '_m_has_field_y_low'): return self._m_has_field_y_low self._m_has_field_y_low = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_y_low', None) @property def has_field_y_high(self): if hasattr(self, '_m_has_field_y_high'): return self._m_has_field_y_high self._m_has_field_y_high = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_y_high', None) class EnumPerfItemValueType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfItemValueType, self.data.value) return getattr(self, '_m_value', None) class EnumGuideOperator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideOperator, self.data.value) return getattr(self, '_m_value', None) class ConfigGadgetUiBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_ui_btn_cfg_path: self.gadget_ui_btn_cfg_path = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_name: self.ui_name = AuxTypes.String(self._io, self, self._root) if self.has_field_on_touch: self.on_touch = Output.EnumTouchInteractType(self._io, self, self._root) if self.has_field_touch_params: self.touch_params = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_show_comb_type: self.show_comb_type = Output.EnumLogicType(self._io, self, self._root) if self.has_field_show_cond_types: self.show_cond_types = Output.ArrayOfEnumGadgetUiItemShowCondTypeLengthU(self._io, self, self._root) if self.has_field_post_gadget_action_params: self.post_gadget_action_params = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_group_name: self.group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumGadgetInteractItemType(self._io, self, self._root) if self.has_field_need_dialog_confirm: self.need_dialog_confirm = self._io.read_u1() if self.has_field_confirm_dialog_title: self.confirm_dialog_title = AuxTypes.String(self._io, self, self._root) if self.has_field_confirm_dialog_content: self.confirm_dialog_content = AuxTypes.String(self._io, self, self._root) @property def has_field_need_dialog_confirm(self): if hasattr(self, '_m_has_field_need_dialog_confirm'): return self._m_has_field_need_dialog_confirm self._m_has_field_need_dialog_confirm = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_need_dialog_confirm', None) @property def has_field_post_gadget_action_params(self): if hasattr(self, '_m_has_field_post_gadget_action_params'): return self._m_has_field_post_gadget_action_params self._m_has_field_post_gadget_action_params = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_post_gadget_action_params', None) @property def has_field_ui_name(self): if hasattr(self, '_m_has_field_ui_name'): return self._m_has_field_ui_name self._m_has_field_ui_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_ui_name', None) @property def has_field_show_comb_type(self): if hasattr(self, '_m_has_field_show_comb_type'): return self._m_has_field_show_comb_type self._m_has_field_show_comb_type = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_show_comb_type', None) @property def has_field_confirm_dialog_content(self): if hasattr(self, '_m_has_field_confirm_dialog_content'): return self._m_has_field_confirm_dialog_content self._m_has_field_confirm_dialog_content = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_confirm_dialog_content', None) @property def has_field_confirm_dialog_title(self): if hasattr(self, '_m_has_field_confirm_dialog_title'): return self._m_has_field_confirm_dialog_title self._m_has_field_confirm_dialog_title = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_confirm_dialog_title', None) @property def has_field_on_touch(self): if hasattr(self, '_m_has_field_on_touch'): return self._m_has_field_on_touch self._m_has_field_on_touch = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_on_touch', None) @property def has_field_group_name(self): if hasattr(self, '_m_has_field_group_name'): return self._m_has_field_group_name self._m_has_field_group_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_group_name', None) @property def has_field_show_cond_types(self): if hasattr(self, '_m_has_field_show_cond_types'): return self._m_has_field_show_cond_types self._m_has_field_show_cond_types = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_cond_types', None) @property def has_field_touch_params(self): if hasattr(self, '_m_has_field_touch_params'): return self._m_has_field_touch_params self._m_has_field_touch_params = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_touch_params', None) @property def has_field_gadget_ui_btn_cfg_path(self): if hasattr(self, '_m_has_field_gadget_ui_btn_cfg_path'): return self._m_has_field_gadget_ui_btn_cfg_path self._m_has_field_gadget_ui_btn_cfg_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_gadget_ui_btn_cfg_path', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_icon', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_item_type', None) class SectrBakeLayersInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_list: self.list = Output.ArrayOfSectrBakeLayerInfoLengthU(self._io, self, self._root) @property def has_field_list(self): if hasattr(self, '_m_has_field_list'): return self._m_has_field_list self._m_has_field_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_list', None) class RandomQuestContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestContentType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_param_str: self.param_str = AuxTypes.String(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_param_str(self): if hasattr(self, '_m_has_field_param_str'): return self._m_has_field_param_str self._m_has_field_param_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param_str', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_count', None) class FireGainCrystalSeedEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) class MatchNewRuleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRaycast(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_raycast_length: self.raycast_length = self._io.read_f4le() if self.has_field_raycast_type: self.raycast_type = Output.EnumRaycastType(self._io, self, self._root) @property def has_field_raycast_length(self): if hasattr(self, '_m_has_field_raycast_length'): return self._m_has_field_raycast_length self._m_has_field_raycast_length = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_raycast_length', None) @property def has_field_raycast_type(self): if hasattr(self, '_m_has_field_raycast_type'): return self._m_has_field_raycast_type self._m_has_field_raycast_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_raycast_type', None) class ModifySkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_delta: self.cd_delta = self._io.read_f4le() if self.has_field_cd_ratio: self.cd_ratio = self._io.read_f4le() @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def has_field_cd_delta(self): if hasattr(self, '_m_has_field_cd_delta'): return self._m_has_field_cd_delta self._m_has_field_cd_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_delta', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_ratio', None) class MoonfinTrialLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigAiNerveTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigAiNerveTargetType, self.data.value) return getattr(self, '_m_value', None) class ConfigEquipController(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sheath_point: self.sheath_point = AuxTypes.String(self._io, self, self._root) if self.has_field_sheath_point: self.dissolve_sheath_fade_delay = self._io.read_f4le() if self.has_field_sheath_point: self.dissolve_sheath_fade_time = self._io.read_f4le() self.sus = self._io.read_u1() if self.has_field_attach_points: self.attach_points = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_sheath_point(self): if hasattr(self, '_m_has_field_sheath_point'): return self._m_has_field_sheath_point self._m_has_field_sheath_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sheath_point', None) @property def has_field_attach_points(self): if hasattr(self, '_m_has_field_attach_points'): return self._m_has_field_attach_points self._m_has_field_attach_points = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_points', None) class ArrayOfRogueDiaryRoomTypeConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RogueDiaryRoomTypeConfig(self._io, self, self._root)) class ConfigWidgetToyCreateGadgetBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_set_camera: self.is_set_camera = self._io.read_u1() if self.has_field_set_camera_angle: self.set_camera_angle = self._io.read_f4le() if self.has_field_do_bag_type: self.do_bag_type = Output.EnumCreateSeverGadgetOpType(self._io, self, self._root) @property def has_field_set_camera_angle(self): if hasattr(self, '_m_has_field_set_camera_angle'): return self._m_has_field_set_camera_angle self._m_has_field_set_camera_angle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_camera_angle', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_do_bag_type(self): if hasattr(self, '_m_has_field_do_bag_type'): return self._m_has_field_do_bag_type self._m_has_field_do_bag_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_do_bag_type', None) @property def has_field_is_set_camera(self): if hasattr(self, '_m_has_field_is_set_camera'): return self._m_has_field_is_set_camera self._m_has_field_is_set_camera = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_set_camera', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class ServerFinishWatcherMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfConfigAiPoseControlItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiPoseControlItem(self._io, self, self._root)) class ConfigLevelArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_polygon_data: self.polygon_data = Output.ConfigPolygonArea(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_polygon_data(self): if hasattr(self, '_m_has_field_polygon_data'): return self._m_has_field_polygon_data self._m_has_field_polygon_data = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_polygon_data', None) class ConfigAudioOperation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_operation: self.operation = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_operation(self): if hasattr(self, '_m_has_field_operation'): return self._m_has_field_operation self._m_has_field_operation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_operation', None) class BroadcastNeuronStimulate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_neuron_name: self.neuron_name = Output.EnumNeuronName(self._io, self, self._root) if self.has_field_stimulate: self.stimulate = self._io.read_u1() if self.has_field_range: self.range = self._io.read_f4le() @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_range', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_neuron_name(self): if hasattr(self, '_m_has_field_neuron_name'): return self._m_has_field_neuron_name self._m_has_field_neuron_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_neuron_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_stimulate(self): if hasattr(self, '_m_has_field_stimulate'): return self._m_has_field_stimulate self._m_has_field_stimulate = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stimulate', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RandomQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCharacter(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shoot_config: self.shoot_config = Output.ConfigAvatarShoot(self._io, self, self._root) if self.has_field_audio: self.audio = Output.ConfigAvatarAudio(self._io, self, self._root) if self.has_field_controller_assembly: self.controller_assembly = Output.ConfigAvatarControllerAssembly(self._io, self, self._root) if self.has_field_move_state_effect: self.move_state_effect = Output.ConfigMoveStateEffect(self._io, self, self._root) if self.has_field_perform: self.perform = Output.ConfigAvatarPerform(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def bind_emotions(self): if hasattr(self, '_m_bind_emotions'): return self._m_bind_emotions self._m_bind_emotions = self.base.bind_emotions return getattr(self, '_m_bind_emotions', None) @property def has_field_controller_assembly(self): if hasattr(self, '_m_has_field_controller_assembly'): return self._m_has_field_controller_assembly self._m_has_field_controller_assembly = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_controller_assembly', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def billboard(self): if hasattr(self, '_m_billboard'): return self._m_billboard self._m_billboard = self.base.billboard return getattr(self, '_m_billboard', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_audio', None) @property def equip_controller(self): if hasattr(self, '_m_equip_controller'): return self._m_equip_controller self._m_equip_controller = self.base.equip_controller return getattr(self, '_m_equip_controller', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def sub_equip_controllers(self): if hasattr(self, '_m_sub_equip_controllers'): return self._m_sub_equip_controllers self._m_sub_equip_controllers = self.base.sub_equip_controllers return getattr(self, '_m_sub_equip_controllers', None) @property def abilities(self): if hasattr(self, '_m_abilities'): return self._m_abilities self._m_abilities = self.base.abilities return getattr(self, '_m_abilities', None) @property def has_field_move_state_effect(self): if hasattr(self, '_m_has_field_move_state_effect'): return self._m_has_field_move_state_effect self._m_has_field_move_state_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_move_state_effect', None) @property def has_field_perform(self): if hasattr(self, '_m_has_field_perform'): return self._m_has_field_perform self._m_has_field_perform = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_perform', None) @property def face(self): if hasattr(self, '_m_face'): return self._m_face self._m_face = self.base.face return getattr(self, '_m_face', None) @property def part_control(self): if hasattr(self, '_m_part_control'): return self._m_part_control self._m_part_control = self.base.part_control return getattr(self, '_m_part_control', None) @property def has_field_shoot_config(self): if hasattr(self, '_m_has_field_shoot_config'): return self._m_has_field_shoot_config self._m_has_field_shoot_config = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shoot_config', None) @property def combat(self): if hasattr(self, '_m_combat'): return self._m_combat self._m_combat = self.base.combat return getattr(self, '_m_combat', None) @property def state_layers(self): if hasattr(self, '_m_state_layers'): return self._m_state_layers self._m_state_layers = self.base.state_layers return getattr(self, '_m_state_layers', None) class UgcAxialTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrStreamObject(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumSectrStreamObjectType(self._io, self, self._root) if self.has_field_game_object_path_hash: self.game_object_path_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_obj_pattern_name_hash: self.obj_pattern_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_magitude: self.magitude = self._io.read_f4le() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_scale: self.scale = Output.Vector(self._io, self, self._root) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_game_object_path_hash(self): if hasattr(self, '_m_has_field_game_object_path_hash'): return self._m_has_field_game_object_path_hash self._m_has_field_game_object_path_hash = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_game_object_path_hash', None) @property def has_field_obj_pattern_name_hash(self): if hasattr(self, '_m_has_field_obj_pattern_name_hash'): return self._m_has_field_obj_pattern_name_hash self._m_has_field_obj_pattern_name_hash = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_obj_pattern_name_hash', None) @property def has_field_magitude(self): if hasattr(self, '_m_has_field_magitude'): return self._m_has_field_magitude self._m_has_field_magitude = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_magitude', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_scale', None) class EnumCutsceneInitPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CutsceneInitPosType, self.data.value) return getattr(self, '_m_value', None) class EnumActionPanelEffectSlot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionPanelEffectSlot, self.data.value) return getattr(self, '_m_value', None) class AttachToAnimatorStateIdMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.AttachToStateIdMixin(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def state_i_ds(self): if hasattr(self, '_m_state_i_ds'): return self._m_state_i_ds self._m_state_i_ds = self.base.state_i_ds return getattr(self, '_m_state_i_ds', None) @property def modifier_name(self): if hasattr(self, '_m_modifier_name'): return self._m_modifier_name self._m_modifier_name = self.base.modifier_name return getattr(self, '_m_modifier_name', None) @property def is_check_on_attach(self): if hasattr(self, '_m_is_check_on_attach'): return self._m_is_check_on_attach self._m_is_check_on_attach = self.base.is_check_on_attach return getattr(self, '_m_is_check_on_attach', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class TypeTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BaseSwitchMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class AttachUiEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_slot: self.effect_slot = Output.EnumActionPanelEffectSlot(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_effect_slot(self): if hasattr(self, '_m_has_field_effect_slot'): return self._m_has_field_effect_slot self._m_has_field_effect_slot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_slot', None) class NpcExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCustomGadgetSlotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CustomGadgetSlotType, self.data.value) return getattr(self, '_m_value', None) class ExpeditionPathExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty_id: self.difficulty_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_super_element: self.super_element = AuxTypes.String(self._io, self, self._root) if self.has_field_basic_reward_id: self.basic_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_reward_id: self.bonus_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_path_name: self.path_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_path_desc: self.path_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_reward_list: self.level_reward_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_basic_reward_id(self): if hasattr(self, '_m_has_field_basic_reward_id'): return self._m_has_field_basic_reward_id self._m_has_field_basic_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_basic_reward_id', None) @property def has_field_level_reward_list(self): if hasattr(self, '_m_has_field_level_reward_list'): return self._m_has_field_level_reward_list self._m_has_field_level_reward_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_level_reward_list', None) @property def has_field_super_element(self): if hasattr(self, '_m_has_field_super_element'): return self._m_has_field_super_element self._m_has_field_super_element = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_super_element', None) @property def has_field_bonus_reward_id(self): if hasattr(self, '_m_has_field_bonus_reward_id'): return self._m_has_field_bonus_reward_id self._m_has_field_bonus_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_bonus_reward_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_difficulty_id(self): if hasattr(self, '_m_has_field_difficulty_id'): return self._m_has_field_difficulty_id self._m_has_field_difficulty_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_difficulty_id', None) @property def has_field_path_desc(self): if hasattr(self, '_m_has_field_path_desc'): return self._m_has_field_path_desc self._m_has_field_path_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_path_desc', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_path_name(self): if hasattr(self, '_m_has_field_path_name'): return self._m_has_field_path_name self._m_has_field_path_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_path_name', None) class ConfigEffectWithThreshold(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_threshold: self.threshold = self._io.read_f4le() if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) @property def has_field_threshold(self): if hasattr(self, '_m_has_field_threshold'): return self._m_has_field_threshold self._m_has_field_threshold = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_threshold', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_name', None) class ConfigJobData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_job_map_data: self.job_map_data = Output.DictOfAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigJob(self._io, self, self._root) @property def has_field_job_map_data(self): if hasattr(self, '_m_has_field_job_map_data'): return self._m_has_field_job_map_data self._m_has_field_job_map_data = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_job_map_data', None) class BooksCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_disuse', None) class ConfigPerfRatingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_perf_rating: self.perf_rating = Output.DictOfEnumPerfRatingCategoryArrayOfConfigPerfRatingLevelLengthU(self._io, self, self._root) if self.has_field_perf_rating_copy_map: self.perf_rating_copy_map = Output.DictOfEnumPerfRatingCategoryEnumPerfRatingCategory(self._io, self, self._root) if self.has_field_perf_rating_default: self.perf_rating_default = Output.DictOfEnumPerfRatingCategoryAuxTypesVlqBase128LeS(self._io, self, self._root) @property def has_field_perf_rating(self): if hasattr(self, '_m_has_field_perf_rating'): return self._m_has_field_perf_rating self._m_has_field_perf_rating = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_perf_rating', None) @property def has_field_perf_rating_copy_map(self): if hasattr(self, '_m_has_field_perf_rating_copy_map'): return self._m_has_field_perf_rating_copy_map self._m_has_field_perf_rating_copy_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_perf_rating_copy_map', None) @property def has_field_perf_rating_default(self): if hasattr(self, '_m_has_field_perf_rating_default'): return self._m_has_field_perf_rating_default self._m_has_field_perf_rating_default = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_perf_rating_default', None) class ConfigGuideAvatarActionCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action: self.action = Output.EnumGuideAvatarAction(self._io, self, self._root) @property def has_field_action(self): if hasattr(self, '_m_has_field_action'): return self._m_has_field_action self._m_has_field_action = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class KvpOfDictAuxTypesStringDispConfigSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigSpecialCamera(self._io, self, self._root) class WeaponExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityCrystalLinkDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PropertyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfNumberArrayItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfNumberArrayItemOverrideInfo(self._io, self, self._root)) class ArrayOfDispConfigRecordActorBaseLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigRecordActorBase(self._io, self, self._root)) class EnumOpenStateCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpenStateCondType, self.data.value) return getattr(self, '_m_value', None) class WidgetEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumChannellerSlabDifficulty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChannellerSlabDifficulty, self.data.value) return getattr(self, '_m_value', None) class ConfigCutscenePreTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_target_day_time: self.target_day_time = self._io.read_f4le() if self.has_field_target_weather: self.target_weather = AuxTypes.String(self._io, self, self._root) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_target_day_time(self): if hasattr(self, '_m_has_field_target_day_time'): return self._m_has_field_target_day_time self._m_has_field_target_day_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_day_time', None) @property def has_field_target_weather(self): if hasattr(self, '_m_has_field_target_weather'): return self._m_has_field_target_weather self._m_has_field_target_weather = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_weather', None) class DungeonEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SceneTransPoint(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_ids: self.dungeon_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_quest_condition_list: self.dungeon_quest_condition_list = Output.DungeonQuestCondition(self._io, self, self._root) if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) if self.has_field_worktop_group_id: self.worktop_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_text_id: self.title_text_id = AuxTypes.String(self._io, self, self._root) if self.has_field_show_level: self.show_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_dungeon_random_list: self.dungeon_random_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dungeon_entry_type: self.dungeon_entry_type = Output.EnumDungeonEntryType(self._io, self, self._root) if self.has_field_forbid_simple_unlock: self.forbid_simple_unlock = self._io.read_u1() if self.has_field_fire_field_event: self.fire_field_event = self._io.read_u1() if self.has_field_dungeon_roster_list: self.dungeon_roster_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_remove_entity_if_locked: self.remove_entity_if_locked = self._io.read_u1() @property def has_field_title_text_id(self): if hasattr(self, '_m_has_field_title_text_id'): return self._m_has_field_title_text_id self._m_has_field_title_text_id = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_title_text_id', None) @property def has_field_dungeon_entry_type(self): if hasattr(self, '_m_has_field_dungeon_entry_type'): return self._m_has_field_dungeon_entry_type self._m_has_field_dungeon_entry_type = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_dungeon_entry_type', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def max_spring_volume(self): if hasattr(self, '_m_max_spring_volume'): return self._m_max_spring_volume self._m_max_spring_volume = self.base.max_spring_volume return getattr(self, '_m_max_spring_volume', None) @property def disable_interaction(self): if hasattr(self, '_m_disable_interaction'): return self._m_disable_interaction self._m_disable_interaction = self.base.disable_interaction return getattr(self, '_m_disable_interaction', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_dungeon_random_list(self): if hasattr(self, '_m_has_field_dungeon_random_list'): return self._m_has_field_dungeon_random_list self._m_has_field_dungeon_random_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_dungeon_random_list', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def npc_id(self): if hasattr(self, '_m_npc_id'): return self._m_npc_id self._m_npc_id = self.base.npc_id return getattr(self, '_m_npc_id', None) @property def map_visibility(self): if hasattr(self, '_m_map_visibility'): return self._m_map_visibility self._m_map_visibility = self.base.map_visibility return getattr(self, '_m_map_visibility', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def cutscene_list(self): if hasattr(self, '_m_cutscene_list'): return self._m_cutscene_list self._m_cutscene_list = self.base.cutscene_list return getattr(self, '_m_cutscene_list', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_size', None) @property def is_forbid_avatar_auto_use_spring(self): if hasattr(self, '_m_is_forbid_avatar_auto_use_spring'): return self._m_is_forbid_avatar_auto_use_spring self._m_is_forbid_avatar_auto_use_spring = self.base.is_forbid_avatar_auto_use_spring return getattr(self, '_m_is_forbid_avatar_auto_use_spring', None) @property def has_field_dungeon_ids(self): if hasattr(self, '_m_has_field_dungeon_ids'): return self._m_has_field_dungeon_ids self._m_has_field_dungeon_ids = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_dungeon_ids', None) @property def show_on_locked_area(self): if hasattr(self, '_m_show_on_locked_area'): return self._m_show_on_locked_area self._m_show_on_locked_area = self.base.show_on_locked_area return getattr(self, '_m_show_on_locked_area', None) @property def has_field_dungeon_roster_list(self): if hasattr(self, '_m_has_field_dungeon_roster_list'): return self._m_has_field_dungeon_roster_list self._m_has_field_dungeon_roster_list = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_dungeon_roster_list', None) @property def has_field_forbid_simple_unlock(self): if hasattr(self, '_m_has_field_forbid_simple_unlock'): return self._m_has_field_forbid_simple_unlock self._m_has_field_forbid_simple_unlock = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_forbid_simple_unlock', None) @property def has_field_show_level(self): if hasattr(self, '_m_has_field_show_level'): return self._m_has_field_show_level self._m_has_field_show_level = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_show_level', None) @property def has_field_dungeon_quest_condition_list(self): if hasattr(self, '_m_has_field_dungeon_quest_condition_list'): return self._m_has_field_dungeon_quest_condition_list self._m_has_field_dungeon_quest_condition_list = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_dungeon_quest_condition_list', None) @property def is_forbid_avatar_revive(self): if hasattr(self, '_m_is_forbid_avatar_revive'): return self._m_is_forbid_avatar_revive self._m_is_forbid_avatar_revive = self.base.is_forbid_avatar_revive return getattr(self, '_m_is_forbid_avatar_revive', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_worktop_group_id(self): if hasattr(self, '_m_has_field_worktop_group_id'): return self._m_has_field_worktop_group_id self._m_has_field_worktop_group_id = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_worktop_group_id', None) @property def has_field_remove_entity_if_locked(self): if hasattr(self, '_m_has_field_remove_entity_if_locked'): return self._m_has_field_remove_entity_if_locked self._m_has_field_remove_entity_if_locked = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_remove_entity_if_locked', None) @property def has_field_fire_field_event(self): if hasattr(self, '_m_has_field_fire_field_event'): return self._m_has_field_fire_field_event self._m_has_field_fire_field_event = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_fire_field_event', None) class DialogExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumActorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActorType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringAuxTypesDynamicFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = AuxTypes.DynamicFloat(self._io, self, self._root) class DictOfEnumElementTypeConfigElementShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementTypeConfigElementShieldResistance(self._io, self, self._root)) class ByBigTeamHasFeatureTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_feature_tag_id: self.feature_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_feature_tag_id(self): if hasattr(self, '_m_has_field_feature_tag_id'): return self._m_has_field_feature_tag_id self._m_has_field_feature_tag_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_feature_tag_id', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigCombatBillboard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBillboard(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_show_hp_bar: self.show_hp_bar = self._io.read_u1() if self.has_field_force_show_distance: self.force_show_distance = self._io.read_f4le() if self.has_field_size: self.size = Output.EnumCombatBillboardSize(self._io, self, self._root) if self.has_field_shield_bar_only: self.shield_bar_only = self._io.read_u1() @property def has_field_force_show_distance(self): if hasattr(self, '_m_has_field_force_show_distance'): return self._m_has_field_force_show_distance self._m_has_field_force_show_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_force_show_distance', None) @property def offset_type(self): if hasattr(self, '_m_offset_type'): return self._m_offset_type self._m_offset_type = self.base.offset_type return getattr(self, '_m_offset_type', None) @property def show_distance(self): if hasattr(self, '_m_show_distance'): return self._m_show_distance self._m_show_distance = self.base.show_distance return getattr(self, '_m_show_distance', None) @property def radius_offset(self): if hasattr(self, '_m_radius_offset'): return self._m_radius_offset self._m_radius_offset = self.base.radius_offset return getattr(self, '_m_radius_offset', None) @property def name_show_distance(self): if hasattr(self, '_m_name_show_distance'): return self._m_name_show_distance self._m_name_show_distance = self.base.name_show_distance return getattr(self, '_m_name_show_distance', None) @property def has_field_show_hp_bar(self): if hasattr(self, '_m_has_field_show_hp_bar'): return self._m_has_field_show_hp_bar self._m_has_field_show_hp_bar = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show_hp_bar', None) @property def enable_self_adapt(self): if hasattr(self, '_m_enable_self_adapt'): return self._m_enable_self_adapt self._m_enable_self_adapt = self.base.enable_self_adapt return getattr(self, '_m_enable_self_adapt', None) @property def has_field_shield_bar_only(self): if hasattr(self, '_m_has_field_shield_bar_only'): return self._m_has_field_shield_bar_only self._m_has_field_shield_bar_only = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_shield_bar_only', None) @property def mark_show_distance(self): if hasattr(self, '_m_mark_show_distance'): return self._m_mark_show_distance self._m_mark_show_distance = self.base.mark_show_distance return getattr(self, '_m_mark_show_distance', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_size', None) @property def attach_point(self): if hasattr(self, '_m_attach_point'): return self._m_attach_point self._m_attach_point = self.base.attach_point return getattr(self, '_m_attach_point', None) @property def force_hide_all_bars(self): if hasattr(self, '_m_force_hide_all_bars'): return self._m_force_hide_all_bars self._m_force_hide_all_bars = self.base.force_hide_all_bars return getattr(self, '_m_force_hide_all_bars', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class EnumWatcherSystemListenType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WatcherSystemListenType, self.data.value) return getattr(self, '_m_value', None) class DictOfEnumElementReactionTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementReactionTypeAuxTypesString(self._io, self, self._root)) class BoredActionPriorityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryStageDifficultyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MichiaeStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_max_offering_level: self.max_offering_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_crystal_exp: self.max_crystal_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab_name: self.tab_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_tab_name(self): if hasattr(self, '_m_has_field_tab_name'): return self._m_has_field_tab_name self._m_has_field_tab_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tab_name', None) @property def has_field_max_crystal_exp(self): if hasattr(self, '_m_has_field_max_crystal_exp'): return self._m_has_field_max_crystal_exp self._m_has_field_max_crystal_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_crystal_exp', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_list', None) @property def has_field_max_offering_level(self): if hasattr(self, '_m_has_field_max_offering_level'): return self._m_has_field_max_offering_level self._m_has_field_max_offering_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_max_offering_level', None) class EnumEquipEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EquipEntityType, self.data.value) return getattr(self, '_m_value', None) class TauntLevelTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumTauntLevel(self._io, self, self._root) if self.has_field_taunt_level_val: self.taunt_level_val = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_taunt_level_val(self): if hasattr(self, '_m_has_field_taunt_level_val'): return self._m_has_field_taunt_level_val self._m_has_field_taunt_level_val = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_taunt_level_val', None) class RogueDungeonCellExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigHomeGatherLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeGather(self._io, self, self._root)) class ActionPanelStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicSingleInequalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class TemplateReminderStyleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiSurroundSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSurroundData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSurroundData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class NewActivityEntryConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetCrashDamage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiSpacialWanderConeWeightData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_normal_area_weight: self.normal_area_weight = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_edge_area_weight: self.edge_area_weight = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_normal_area_weight(self): if hasattr(self, '_m_has_field_normal_area_weight'): return self._m_has_field_normal_area_weight self._m_has_field_normal_area_weight = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_normal_area_weight', None) @property def has_field_edge_area_weight(self): if hasattr(self, '_m_has_field_edge_area_weight'): return self._m_has_field_edge_area_weight self._m_has_field_edge_area_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_edge_area_weight', None) class EnableAvatarFlyStateTrail(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class MusicGamePreviewConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfConfigEntityBlackGrpLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfConfigEntityBlackGrpLengthU(self._io, self, self._root)) class ExhibitionServerTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLevelActionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_action_points: self.action_points = Output.ArrayOfConfigActionPointLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_action_points(self): if hasattr(self, '_m_has_field_action_points'): return self._m_has_field_action_points self._m_has_field_action_points = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_points', None) class ConfigAudioMutualExclusion(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_exclusion_pairs: self.exclusion_pairs = Output.ArrayOfAudioMutualExclusionLengthU(self._io, self, self._root) @property def has_field_exclusion_pairs(self): if hasattr(self, '_m_has_field_exclusion_pairs'): return self._m_has_field_exclusion_pairs self._m_has_field_exclusion_pairs = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_exclusion_pairs', None) class LevelTagGroupsExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_tag_group_list: self.level_tag_group_list = Output.ArrayOfLevelTagGroupLengthS(self._io, self, self._root) if self.has_field_initial_level_tag_id_list: self.initial_level_tag_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_change_cd: self.change_cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_level_tag_group_list(self): if hasattr(self, '_m_has_field_level_tag_group_list'): return self._m_has_field_level_tag_group_list self._m_has_field_level_tag_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_tag_group_list', None) @property def has_field_initial_level_tag_id_list(self): if hasattr(self, '_m_has_field_initial_level_tag_id_list'): return self._m_has_field_initial_level_tag_id_list self._m_has_field_initial_level_tag_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_initial_level_tag_id_list', None) @property def has_field_change_cd(self): if hasattr(self, '_m_has_field_change_cd'): return self._m_has_field_change_cd self._m_has_field_change_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_change_cd', None) class DictOfEnumOptionTypeConfigParticleEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumOptionTypeConfigParticleEffectSetting(self._io, self, self._root)) class HealHp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_amount: self.amount = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_caster_max_hp_ratio: self.amount_by_caster_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_target_max_hp_ratio: self.amount_by_target_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_target_current_hp_ratio: self.amount_by_target_current_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_caster_attack_ratio: self.amount_by_caster_attack_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_mute_heal_effect: self.mute_heal_effect = self._io.read_u1() if self.has_field_heal_ratio: self.heal_ratio = self._io.read_f4le() if self.has_field_ignore_ability_property: self.ignore_ability_property = self._io.read_u1() @property def has_field_amount(self): if hasattr(self, '_m_has_field_amount'): return self._m_has_field_amount self._m_has_field_amount = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_amount', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_amount_by_target_max_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_target_max_hp_ratio'): return self._m_has_field_amount_by_target_max_hp_ratio self._m_has_field_amount_by_target_max_hp_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_amount_by_target_max_hp_ratio', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_amount_by_target_current_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_target_current_hp_ratio'): return self._m_has_field_amount_by_target_current_hp_ratio self._m_has_field_amount_by_target_current_hp_ratio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_amount_by_target_current_hp_ratio', None) @property def has_field_heal_ratio(self): if hasattr(self, '_m_has_field_heal_ratio'): return self._m_has_field_heal_ratio self._m_has_field_heal_ratio = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_heal_ratio', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_ignore_ability_property(self): if hasattr(self, '_m_has_field_ignore_ability_property'): return self._m_has_field_ignore_ability_property self._m_has_field_ignore_ability_property = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_ignore_ability_property', None) @property def has_field_mute_heal_effect(self): if hasattr(self, '_m_has_field_mute_heal_effect'): return self._m_has_field_mute_heal_effect self._m_has_field_mute_heal_effect = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_mute_heal_effect', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_amount_by_caster_attack_ratio(self): if hasattr(self, '_m_has_field_amount_by_caster_attack_ratio'): return self._m_has_field_amount_by_caster_attack_ratio self._m_has_field_amount_by_caster_attack_ratio = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_amount_by_caster_attack_ratio', None) @property def has_field_amount_by_caster_max_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_caster_max_hp_ratio'): return self._m_has_field_amount_by_caster_max_hp_ratio self._m_has_field_amount_by_caster_max_hp_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_amount_by_caster_max_hp_ratio', None) class InteractTriggerAbilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfCustomGadgetSlotGroupLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CustomGadgetSlotGroup(self._io, self, self._root)) class AttachEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_scale: self.scale = self._io.read_f4le() if self.has_field_effect_templete_id: self.effect_templete_id = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_set_self_as_effect_plugin_target: self.set_self_as_effect_plugin_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_effect_templete_id(self): if hasattr(self, '_m_has_field_effect_templete_id'): return self._m_has_field_effect_templete_id self._m_has_field_effect_templete_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_effect_templete_id', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_set_self_as_effect_plugin_target(self): if hasattr(self, '_m_has_field_set_self_as_effect_plugin_target'): return self._m_has_field_set_self_as_effect_plugin_target self._m_has_field_set_self_as_effect_plugin_target = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_set_self_as_effect_plugin_target', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class DiePatternSwitchMixinPriorityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetTakePhoto(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_has_camera_effect: self.has_camera_effect = self._io.read_u1() if self.has_field_camera_ui_effect: self.camera_ui_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_camera_screen_effect: self.camera_screen_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_main_camera_effect: self.main_camera_effect = AuxTypes.String(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def has_field_camera_ui_effect(self): if hasattr(self, '_m_has_field_camera_ui_effect'): return self._m_has_field_camera_ui_effect self._m_has_field_camera_ui_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camera_ui_effect', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_camera_screen_effect(self): if hasattr(self, '_m_has_field_camera_screen_effect'): return self._m_has_field_camera_screen_effect self._m_has_field_camera_screen_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camera_screen_effect', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_main_camera_effect(self): if hasattr(self, '_m_has_field_main_camera_effect'): return self._m_has_field_main_camera_effect self._m_has_field_main_camera_effect = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_main_camera_effect', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def has_field_has_camera_effect(self): if hasattr(self, '_m_has_field_has_camera_effect'): return self._m_has_field_has_camera_effect self._m_has_field_has_camera_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_has_camera_effect', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class AddGlobalPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_set_target: self.set_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_target(self): if hasattr(self, '_m_has_field_set_target'): return self._m_has_field_set_target self._m_has_field_set_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class EnumRegionSearchType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionSearchType, self.data.value) return getattr(self, '_m_value', None) class ConfigQteStepPlayAudioAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_audio_name: self.audio_name = AuxTypes.String(self._io, self, self._root) @property def has_field_audio_name(self): if hasattr(self, '_m_has_field_audio_name'): return self._m_has_field_audio_name self._m_has_field_audio_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_audio_name', None) @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) class DispConfigBillboard(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBillboard(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCombatBillboard(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigGadgetIconBillboard(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigProgressBillboard(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class EnumChallengeEventMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChallengeEventMarkType, self.data.value) return getattr(self, '_m_value', None) class ActivityHachiStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_title: self.quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_desc: self.quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stealth_title: self.stealth_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_desc: self.battle_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stealth_watcher: self.stealth_watcher = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_watcher: self.battle_watcher = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stealth_group: self.stealth_group = AuxTypes.String(self._io, self, self._root) if self.has_field_battle_group: self.battle_group = AuxTypes.String(self._io, self, self._root) if self.has_field_stealth_push_tips: self.stealth_push_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_push_tips: self.battle_push_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tip: self.push_tip = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stealth_trigger_point_mark_pos: self.stealth_trigger_point_mark_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_stealth_mark_pos: self.stealth_mark_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_battle_mark_pos: self.battle_mark_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_final_quest_id: self.final_quest_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_map_mark_load_quest: self.map_mark_load_quest = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stealth_challenge_index: self.stealth_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_challenge_index: self.battle_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stealth_radius: self.stealth_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_radius: self.battle_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_map_mark_load_quest(self): if hasattr(self, '_m_has_field_map_mark_load_quest'): return self._m_has_field_map_mark_load_quest self._m_has_field_map_mark_load_quest = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_map_mark_load_quest', None) @property def has_field_battle_watcher(self): if hasattr(self, '_m_has_field_battle_watcher'): return self._m_has_field_battle_watcher self._m_has_field_battle_watcher = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_battle_watcher', None) @property def has_field_battle_group(self): if hasattr(self, '_m_has_field_battle_group'): return self._m_has_field_battle_group self._m_has_field_battle_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_battle_group', None) @property def has_field_battle_radius(self): if hasattr(self, '_m_has_field_battle_radius'): return self._m_has_field_battle_radius self._m_has_field_battle_radius = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_battle_radius', None) @property def has_field_quest_desc(self): if hasattr(self, '_m_has_field_quest_desc'): return self._m_has_field_quest_desc self._m_has_field_quest_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_quest_desc', None) @property def has_field_stealth_group(self): if hasattr(self, '_m_has_field_stealth_group'): return self._m_has_field_stealth_group self._m_has_field_stealth_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_stealth_group', None) @property def has_field_battle_desc(self): if hasattr(self, '_m_has_field_battle_desc'): return self._m_has_field_battle_desc self._m_has_field_battle_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_battle_desc', None) @property def has_field_push_tip(self): if hasattr(self, '_m_has_field_push_tip'): return self._m_has_field_push_tip self._m_has_field_push_tip = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_push_tip', None) @property def has_field_stealth_title(self): if hasattr(self, '_m_has_field_stealth_title'): return self._m_has_field_stealth_title self._m_has_field_stealth_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_stealth_title', None) @property def has_field_stealth_challenge_index(self): if hasattr(self, '_m_has_field_stealth_challenge_index'): return self._m_has_field_stealth_challenge_index self._m_has_field_stealth_challenge_index = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_stealth_challenge_index', None) @property def has_field_stealth_trigger_point_mark_pos(self): if hasattr(self, '_m_has_field_stealth_trigger_point_mark_pos'): return self._m_has_field_stealth_trigger_point_mark_pos self._m_has_field_stealth_trigger_point_mark_pos = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_stealth_trigger_point_mark_pos', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_quest_title(self): if hasattr(self, '_m_has_field_quest_title'): return self._m_has_field_quest_title self._m_has_field_quest_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_quest_title', None) @property def has_field_stealth_radius(self): if hasattr(self, '_m_has_field_stealth_radius'): return self._m_has_field_stealth_radius self._m_has_field_stealth_radius = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_stealth_radius', None) @property def has_field_battle_push_tips(self): if hasattr(self, '_m_has_field_battle_push_tips'): return self._m_has_field_battle_push_tips self._m_has_field_battle_push_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_battle_push_tips', None) @property def has_field_stealth_push_tips(self): if hasattr(self, '_m_has_field_stealth_push_tips'): return self._m_has_field_stealth_push_tips self._m_has_field_stealth_push_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_stealth_push_tips', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_battle_challenge_index(self): if hasattr(self, '_m_has_field_battle_challenge_index'): return self._m_has_field_battle_challenge_index self._m_has_field_battle_challenge_index = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_battle_challenge_index', None) @property def has_field_stealth_mark_pos(self): if hasattr(self, '_m_has_field_stealth_mark_pos'): return self._m_has_field_stealth_mark_pos self._m_has_field_stealth_mark_pos = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_stealth_mark_pos', None) @property def has_field_battle_mark_pos(self): if hasattr(self, '_m_has_field_battle_mark_pos'): return self._m_has_field_battle_mark_pos self._m_has_field_battle_mark_pos = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_battle_mark_pos', None) @property def has_field_stealth_watcher(self): if hasattr(self, '_m_has_field_stealth_watcher'): return self._m_has_field_stealth_watcher self._m_has_field_stealth_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_stealth_watcher', None) @property def has_field_final_quest_id(self): if hasattr(self, '_m_has_field_final_quest_id'): return self._m_has_field_final_quest_id self._m_has_field_final_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_final_quest_id', None) class NewActivityOverlapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_type: self.activity_type = Output.EnumNewActivityType(self._io, self, self._root) @property def has_field_activity_type(self): if hasattr(self, '_m_has_field_activity_type'): return self._m_has_field_activity_type self._m_has_field_activity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_type', None) class AvatarSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_icon: self.skill_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_is_ranged: self.is_ranged = self._io.read_u1() if self.has_field_cd_time: self.cd_time = self._io.read_f4le() if self.has_field_ignore_cd_minus_ratio: self.ignore_cd_minus_ratio = self._io.read_u1() if self.has_field_cost_stamina: self.cost_stamina = self._io.read_f4le() if self.has_field_cost_elem_type: self.cost_elem_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_cost_elem_val: self.cost_elem_val = self._io.read_f4le() if self.has_field_max_charge_num: self.max_charge_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_trigger_id: self.trigger_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_lock_shape: self.lock_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_lock_weight_params: self.lock_weight_params = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_is_attack_camera_lock: self.is_attack_camera_lock = self._io.read_u1() if self.has_field_drag_type: self.drag_type = Output.EnumSkillDrag(self._io, self, self._root) if self.has_field_show_icon_arrow: self.show_icon_arrow = self._io.read_u1() if self.has_field_need_monitor: self.need_monitor = Output.EnumMonitorType(self._io, self, self._root) if self.has_field_default_locked: self.default_locked = self._io.read_u1() if self.has_field_buff_icon: self.buff_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_proud_skill_group_id: self.proud_skill_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_energy_min: self.energy_min = self._io.read_f4le() if self.has_field_force_can_do_skill: self.force_can_do_skill = self._io.read_u1() if self.has_field_cd_slot: self.cd_slot = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_store: self.need_store = self._io.read_u1() if self.has_field_share_cdid: self.share_cdid = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_force_can_do_skill(self): if hasattr(self, '_m_has_field_force_can_do_skill'): return self._m_has_field_force_can_do_skill self._m_has_field_force_can_do_skill = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_force_can_do_skill', None) @property def has_field_energy_min(self): if hasattr(self, '_m_has_field_energy_min'): return self._m_has_field_energy_min self._m_has_field_energy_min = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_energy_min', None) @property def has_field_cost_elem_val(self): if hasattr(self, '_m_has_field_cost_elem_val'): return self._m_has_field_cost_elem_val self._m_has_field_cost_elem_val = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cost_elem_val', None) @property def has_field_lock_shape(self): if hasattr(self, '_m_has_field_lock_shape'): return self._m_has_field_lock_shape self._m_has_field_lock_shape = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_lock_shape', None) @property def has_field_buff_icon(self): if hasattr(self, '_m_has_field_buff_icon'): return self._m_has_field_buff_icon self._m_has_field_buff_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_buff_icon', None) @property def has_field_max_charge_num(self): if hasattr(self, '_m_has_field_max_charge_num'): return self._m_has_field_max_charge_num self._m_has_field_max_charge_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_max_charge_num', None) @property def has_field_proud_skill_group_id(self): if hasattr(self, '_m_has_field_proud_skill_group_id'): return self._m_has_field_proud_skill_group_id self._m_has_field_proud_skill_group_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_proud_skill_group_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_need_monitor(self): if hasattr(self, '_m_has_field_need_monitor'): return self._m_has_field_need_monitor self._m_has_field_need_monitor = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_need_monitor', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_share_cdid(self): if hasattr(self, '_m_has_field_share_cdid'): return self._m_has_field_share_cdid self._m_has_field_share_cdid = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_share_cdid', None) @property def has_field_cost_stamina(self): if hasattr(self, '_m_has_field_cost_stamina'): return self._m_has_field_cost_stamina self._m_has_field_cost_stamina = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cost_stamina', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_show_icon_arrow(self): if hasattr(self, '_m_has_field_show_icon_arrow'): return self._m_has_field_show_icon_arrow self._m_has_field_show_icon_arrow = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_show_icon_arrow', None) @property def has_field_ignore_cd_minus_ratio(self): if hasattr(self, '_m_has_field_ignore_cd_minus_ratio'): return self._m_has_field_ignore_cd_minus_ratio self._m_has_field_ignore_cd_minus_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_ignore_cd_minus_ratio', None) @property def has_field_need_store(self): if hasattr(self, '_m_has_field_need_store'): return self._m_has_field_need_store self._m_has_field_need_store = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_need_store', None) @property def has_field_drag_type(self): if hasattr(self, '_m_has_field_drag_type'): return self._m_has_field_drag_type self._m_has_field_drag_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_drag_type', None) @property def has_field_cd_slot(self): if hasattr(self, '_m_has_field_cd_slot'): return self._m_has_field_cd_slot self._m_has_field_cd_slot = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_cd_slot', None) @property def has_field_cd_time(self): if hasattr(self, '_m_has_field_cd_time'): return self._m_has_field_cd_time self._m_has_field_cd_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cd_time', None) @property def has_field_default_locked(self): if hasattr(self, '_m_has_field_default_locked'): return self._m_has_field_default_locked self._m_has_field_default_locked = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_default_locked', None) @property def has_field_is_attack_camera_lock(self): if hasattr(self, '_m_has_field_is_attack_camera_lock'): return self._m_has_field_is_attack_camera_lock self._m_has_field_is_attack_camera_lock = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_attack_camera_lock', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_is_ranged(self): if hasattr(self, '_m_has_field_is_ranged'): return self._m_has_field_is_ranged self._m_has_field_is_ranged = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_ranged', None) @property def has_field_lock_weight_params(self): if hasattr(self, '_m_has_field_lock_weight_params'): return self._m_has_field_lock_weight_params self._m_has_field_lock_weight_params = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_lock_weight_params', None) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_trigger_id', None) @property def has_field_cost_elem_type(self): if hasattr(self, '_m_has_field_cost_elem_type'): return self._m_has_field_cost_elem_type self._m_has_field_cost_elem_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cost_elem_type', None) @property def has_field_skill_icon(self): if hasattr(self, '_m_has_field_skill_icon'): return self._m_has_field_skill_icon self._m_has_field_skill_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_skill_icon', None) class ActivityChessScheduleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAbilityPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ability_paths: self.ability_paths = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ability_paths(self): if hasattr(self, '_m_has_field_ability_paths'): return self._m_has_field_ability_paths self._m_has_field_ability_paths = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_paths', None) class DailyTaskDropConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward_id: self.preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) @property def has_field_preview_reward_id(self): if hasattr(self, '_m_has_field_preview_reward_id'): return self._m_has_field_preview_reward_id self._m_has_field_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_preview_reward_id', None) class PhotographExpressionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2fireworksSkillDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeSConfigAiFishingBitesBaitData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingBitesBaitData(self._io, self, self._root)) class BartenderCupTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiWanderSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_threat_level_limit: self.threat_level_limit = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_default_setting: self.default_setting = Output.ConfigAiWanderData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiWanderData(self._io, self, self._root) @property def has_field_threat_level_limit(self): if hasattr(self, '_m_has_field_threat_level_limit'): return self._m_has_field_threat_level_limit self._m_has_field_threat_level_limit = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_threat_level_limit', None) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigSetAnimatorAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_param_type: self.param_type = Output.EnumAnimatorParamType2(self._io, self, self._root) if self.has_field_param_name: self.param_name = AuxTypes.String(self._io, self, self._root) if self.has_field_int_value: self.int_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_float_value: self.float_value = self._io.read_f4le() if self.has_field_bool_value: self.bool_value = self._io.read_u1() @property def has_field_int_value(self): if hasattr(self, '_m_has_field_int_value'): return self._m_has_field_int_value self._m_has_field_int_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_int_value', None) @property def has_field_param_type(self): if hasattr(self, '_m_has_field_param_type'): return self._m_has_field_param_type self._m_has_field_param_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param_type', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_float_value(self): if hasattr(self, '_m_has_field_float_value'): return self._m_has_field_float_value self._m_has_field_float_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_float_value', None) @property def has_field_param_name(self): if hasattr(self, '_m_has_field_param_name'): return self._m_has_field_param_name self._m_has_field_param_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param_name', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_bool_value(self): if hasattr(self, '_m_has_field_bool_value'): return self._m_has_field_bool_value self._m_has_field_bool_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_bool_value', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class FaceAnimationFrameBlock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFurnitureDeployType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FurnitureDeployType, self.data.value) return getattr(self, '_m_value', None) class EnumActivitySkillTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivitySkillTarget, self.data.value) return getattr(self, '_m_value', None) class ConfigAbilityPropertyEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumPropertyType(self._io, self, self._root) if self.has_field_default_value: self.default_value = self._io.read_f4le() if self.has_field_ceiling: self.ceiling = self._io.read_f4le() if self.has_field_floor: self.floor = self._io.read_f4le() if self.has_field_stacking: self.stacking = Output.EnumStackMethod(self._io, self, self._root) if self.has_field_succeed: self.succeed = self._io.read_u1() if self.has_field_use_tag: self.use_tag = self._io.read_u1() if self.has_field_limited_tag_ceiling: self.limited_tag_ceiling = self._io.read_f4le() if self.has_field_limited_tag_floor: self.limited_tag_floor = self._io.read_f4le() @property def has_field_limited_tag_ceiling(self): if hasattr(self, '_m_has_field_limited_tag_ceiling'): return self._m_has_field_limited_tag_ceiling self._m_has_field_limited_tag_ceiling = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_limited_tag_ceiling', None) @property def has_field_limited_tag_floor(self): if hasattr(self, '_m_has_field_limited_tag_floor'): return self._m_has_field_limited_tag_floor self._m_has_field_limited_tag_floor = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_limited_tag_floor', None) @property def has_field_default_value(self): if hasattr(self, '_m_has_field_default_value'): return self._m_has_field_default_value self._m_has_field_default_value = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_default_value', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_use_tag(self): if hasattr(self, '_m_has_field_use_tag'): return self._m_has_field_use_tag self._m_has_field_use_tag = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_use_tag', None) @property def has_field_ceiling(self): if hasattr(self, '_m_has_field_ceiling'): return self._m_has_field_ceiling self._m_has_field_ceiling = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_ceiling', None) @property def has_field_stacking(self): if hasattr(self, '_m_has_field_stacking'): return self._m_has_field_stacking self._m_has_field_stacking = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_stacking', None) @property def has_field_succeed(self): if hasattr(self, '_m_has_field_succeed'): return self._m_has_field_succeed self._m_has_field_succeed = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_succeed', None) @property def has_field_floor(self): if hasattr(self, '_m_has_field_floor'): return self._m_has_field_floor self._m_has_field_floor = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_floor', None) class EnumShadowQuality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShadowQuality, self.data.value) return getattr(self, '_m_value', None) class ConfigAiBuddySkillCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_select_range: self.select_range = self._io.read_f4le() if self.has_field_buddy_scoring: self.buddy_scoring = Output.ConfigAiBuddyScoring(self._io, self, self._root) @property def has_field_select_range(self): if hasattr(self, '_m_has_field_select_range'): return self._m_has_field_select_range self._m_has_field_select_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_select_range', None) @property def has_field_buddy_scoring(self): if hasattr(self, '_m_has_field_buddy_scoring'): return self._m_has_field_buddy_scoring self._m_has_field_buddy_scoring = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_buddy_scoring', None) class ConfigLanguageSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_text_show_types: self.text_show_types = Output.DictOfAuxTypesStringArrayOfEnumTextLanguageTypeLengthU(self._io, self, self._root) if self.has_field_text_disable_types: self.text_disable_types = Output.DictOfAuxTypesStringArrayOfEnumTextLanguageTypeLengthU(self._io, self, self._root) if self.has_field_voice_show_types: self.voice_show_types = Output.DictOfAuxTypesStringArrayOfEnumVoiceLanguageTypeLengthU(self._io, self, self._root) if self.has_field_voice_disable_types: self.voice_disable_types = Output.DictOfAuxTypesStringArrayOfEnumVoiceLanguageTypeLengthU(self._io, self, self._root) @property def has_field_text_show_types(self): if hasattr(self, '_m_has_field_text_show_types'): return self._m_has_field_text_show_types self._m_has_field_text_show_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_text_show_types', None) @property def has_field_text_disable_types(self): if hasattr(self, '_m_has_field_text_disable_types'): return self._m_has_field_text_disable_types self._m_has_field_text_disable_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_text_disable_types', None) @property def has_field_voice_show_types(self): if hasattr(self, '_m_has_field_voice_show_types'): return self._m_has_field_voice_show_types self._m_has_field_voice_show_types = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_voice_show_types', None) @property def has_field_voice_disable_types(self): if hasattr(self, '_m_has_field_voice_disable_types'): return self._m_has_field_voice_disable_types self._m_has_field_voice_disable_types = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_voice_disable_types', None) class ArrayOfIrodoriPoetryScanConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.IrodoriPoetryScanConfig(self._io, self, self._root)) class ConfigBulletMoveAngle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGroupEntityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GroupEntityType, self.data.value) return getattr(self, '_m_value', None) class SummerTimeV2boatStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_type: self.condition_type = Output.ArrayOfEnumSummerTimeV2boatConditionTypeLengthS(self._io, self, self._root) if self.has_field_condition_param: self.condition_param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_condition_desc: self.condition_desc = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_condition_result: self.condition_result = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_condition_desc(self): if hasattr(self, '_m_has_field_condition_desc'): return self._m_has_field_condition_desc self._m_has_field_condition_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_condition_desc', None) @property def has_field_condition_result(self): if hasattr(self, '_m_has_field_condition_result'): return self._m_has_field_condition_result self._m_has_field_condition_result = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_condition_result', None) @property def has_field_condition_type(self): if hasattr(self, '_m_has_field_condition_type'): return self._m_has_field_condition_type self._m_has_field_condition_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_condition_type', None) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_condition_param(self): if hasattr(self, '_m_has_field_condition_param'): return self._m_has_field_condition_param self._m_has_field_condition_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_condition_param', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_list', None) class TalkBeginWayComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EquipEntityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumIrodoriChessCardNumericalModificationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardNumericalModificationType, self.data.value) return getattr(self, '_m_value', None) class EquipAffixExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_affix_id: self.affix_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_config: self.open_config = AuxTypes.String(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_open_config(self): if hasattr(self, '_m_has_field_open_config'): return self._m_has_field_open_config self._m_has_field_open_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_config', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_affix_id(self): if hasattr(self, '_m_has_field_affix_id'): return self._m_has_field_affix_id self._m_has_field_affix_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_affix_id', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_param_list', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_id', None) class QuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class VoiceSound(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_personality: self.personality = Output.EnumVoicePersonality(self._io, self, self._root) if self.has_field_positioning: self.positioning = Output.EnumVoicePositioning(self._io, self, self._root) if self.has_field_sound_name: self.sound_name = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_personality(self): if hasattr(self, '_m_has_field_personality'): return self._m_has_field_personality self._m_has_field_personality = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_personality', None) @property def has_field_positioning(self): if hasattr(self, '_m_has_field_positioning'): return self._m_has_field_positioning self._m_has_field_positioning = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_positioning', None) @property def has_field_sound_name(self): if hasattr(self, '_m_has_field_sound_name'): return self._m_has_field_sound_name self._m_has_field_sound_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sound_name', None) class ActivityGachaStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_stage_id: self.next_stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_tech: self.is_tech = self._io.read_u1() if self.has_field_type: self.type = Output.EnumActivityGachaTargetType(self._io, self, self._root) if self.has_field_group_id_list: self.group_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_num_list: self.group_num_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stage_group_id_list: self.stage_group_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_task_content_list: self.task_content_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_need_finish: self.is_need_finish = self._io.read_u1() if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_quest_id: self.open_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_group_id_list(self): if hasattr(self, '_m_has_field_group_id_list'): return self._m_has_field_group_id_list self._m_has_field_group_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_group_id_list', None) @property def has_field_task_content_list(self): if hasattr(self, '_m_has_field_task_content_list'): return self._m_has_field_task_content_list self._m_has_field_task_content_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_task_content_list', None) @property def has_field_next_stage_id(self): if hasattr(self, '_m_has_field_next_stage_id'): return self._m_has_field_next_stage_id self._m_has_field_next_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_next_stage_id', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_is_need_finish(self): if hasattr(self, '_m_has_field_is_need_finish'): return self._m_has_field_is_need_finish self._m_has_field_is_need_finish = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_is_need_finish', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_group_num_list(self): if hasattr(self, '_m_has_field_group_num_list'): return self._m_has_field_group_num_list self._m_has_field_group_num_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_group_num_list', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_open_quest_id(self): if hasattr(self, '_m_has_field_open_quest_id'): return self._m_has_field_open_quest_id self._m_has_field_open_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_open_quest_id', None) @property def has_field_stage_group_id_list(self): if hasattr(self, '_m_has_field_stage_group_id_list'): return self._m_has_field_stage_group_id_list self._m_has_field_stage_group_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_stage_group_id_list', None) @property def has_field_is_tech(self): if hasattr(self, '_m_has_field_is_tech'): return self._m_has_field_is_tech self._m_has_field_is_tech = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_tech', None) class TreeTypeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GeneralRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_use_condense_resin: self.use_condense_resin = self._io.read_u1() if self.has_field_reward_source_system: self.reward_source_system = Output.EnumRewardSourceSystemType(self._io, self, self._root) if self.has_field_reward_source_system_para: self.reward_source_system_para = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stamina_enough: self.stamina_enough = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stamina_less: self.stamina_less = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condense_resin_stamina_enough: self.condense_resin_stamina_enough = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condense_resin_stamina_less: self.condense_resin_stamina_less = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_using_activity_coin: self.using_activity_coin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_using_activity_coin_button: self.using_activity_coin_button = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_confirm: self.confirm = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resin_monthly: self.resin_monthly = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_insufficient: self.insufficient = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_insufficient_useitem: self.insufficient_useitem = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condense_resin: self.condense_resin = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_insufficient(self): if hasattr(self, '_m_has_field_insufficient'): return self._m_has_field_insufficient self._m_has_field_insufficient = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_insufficient', None) @property def has_field_confirm(self): if hasattr(self, '_m_has_field_confirm'): return self._m_has_field_confirm self._m_has_field_confirm = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_confirm', None) @property def has_field_using_activity_coin(self): if hasattr(self, '_m_has_field_using_activity_coin'): return self._m_has_field_using_activity_coin self._m_has_field_using_activity_coin = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_using_activity_coin', None) @property def has_field_insufficient_useitem(self): if hasattr(self, '_m_has_field_insufficient_useitem'): return self._m_has_field_insufficient_useitem self._m_has_field_insufficient_useitem = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_insufficient_useitem', None) @property def has_field_use_condense_resin(self): if hasattr(self, '_m_has_field_use_condense_resin'): return self._m_has_field_use_condense_resin self._m_has_field_use_condense_resin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_use_condense_resin', None) @property def has_field_condense_resin_stamina_enough(self): if hasattr(self, '_m_has_field_condense_resin_stamina_enough'): return self._m_has_field_condense_resin_stamina_enough self._m_has_field_condense_resin_stamina_enough = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_condense_resin_stamina_enough', None) @property def has_field_using_activity_coin_button(self): if hasattr(self, '_m_has_field_using_activity_coin_button'): return self._m_has_field_using_activity_coin_button self._m_has_field_using_activity_coin_button = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_using_activity_coin_button', None) @property def has_field_condense_resin_stamina_less(self): if hasattr(self, '_m_has_field_condense_resin_stamina_less'): return self._m_has_field_condense_resin_stamina_less self._m_has_field_condense_resin_stamina_less = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_condense_resin_stamina_less', None) @property def has_field_reward_source_system(self): if hasattr(self, '_m_has_field_reward_source_system'): return self._m_has_field_reward_source_system self._m_has_field_reward_source_system = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_source_system', None) @property def has_field_reward_source_system_para(self): if hasattr(self, '_m_has_field_reward_source_system_para'): return self._m_has_field_reward_source_system_para self._m_has_field_reward_source_system_para = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_source_system_para', None) @property def has_field_condense_resin(self): if hasattr(self, '_m_has_field_condense_resin'): return self._m_has_field_condense_resin self._m_has_field_condense_resin = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_condense_resin', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_resin_monthly(self): if hasattr(self, '_m_has_field_resin_monthly'): return self._m_has_field_resin_monthly self._m_has_field_resin_monthly = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_resin_monthly', None) @property def has_field_stamina_enough(self): if hasattr(self, '_m_has_field_stamina_enough'): return self._m_has_field_stamina_enough self._m_has_field_stamina_enough = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_stamina_enough', None) @property def has_field_stamina_less(self): if hasattr(self, '_m_has_field_stamina_less'): return self._m_has_field_stamina_less self._m_has_field_stamina_less = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_stamina_less', None) class ConfigAudioDynamicRayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ray_per_frame: self.ray_per_frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_moving_lerp_ratio: self.moving_lerp_ratio = self._io.read_f4le() if self.has_field_stand_lerp_ratio: self.stand_lerp_ratio = self._io.read_f4le() if self.has_field_ray_max_distance: self.ray_max_distance = self._io.read_f4le() if self.has_field_is_debug: self.is_debug = self._io.read_u1() if self.has_field_rtpc_param: self.rtpc_param = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_grass_count_rtpc: self.grass_count_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_cone_angle: self.cone_angle = self._io.read_f4le() if self.has_field_left_space_openness_rtpc_key: self.left_space_openness_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_right_space_openness_rtpc_key: self.right_space_openness_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_grass_count_rtpc(self): if hasattr(self, '_m_has_field_grass_count_rtpc'): return self._m_has_field_grass_count_rtpc self._m_has_field_grass_count_rtpc = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_grass_count_rtpc', None) @property def has_field_is_debug(self): if hasattr(self, '_m_has_field_is_debug'): return self._m_has_field_is_debug self._m_has_field_is_debug = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_is_debug', None) @property def has_field_rtpc_param(self): if hasattr(self, '_m_has_field_rtpc_param'): return self._m_has_field_rtpc_param self._m_has_field_rtpc_param = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_rtpc_param', None) @property def has_field_ray_per_frame(self): if hasattr(self, '_m_has_field_ray_per_frame'): return self._m_has_field_ray_per_frame self._m_has_field_ray_per_frame = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_ray_per_frame', None) @property def has_field_ray_max_distance(self): if hasattr(self, '_m_has_field_ray_max_distance'): return self._m_has_field_ray_max_distance self._m_has_field_ray_max_distance = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_ray_max_distance', None) @property def has_field_stand_lerp_ratio(self): if hasattr(self, '_m_has_field_stand_lerp_ratio'): return self._m_has_field_stand_lerp_ratio self._m_has_field_stand_lerp_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_stand_lerp_ratio', None) @property def has_field_moving_lerp_ratio(self): if hasattr(self, '_m_has_field_moving_lerp_ratio'): return self._m_has_field_moving_lerp_ratio self._m_has_field_moving_lerp_ratio = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_moving_lerp_ratio', None) @property def has_field_left_space_openness_rtpc_key(self): if hasattr(self, '_m_has_field_left_space_openness_rtpc_key'): return self._m_has_field_left_space_openness_rtpc_key self._m_has_field_left_space_openness_rtpc_key = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_left_space_openness_rtpc_key', None) @property def has_field_right_space_openness_rtpc_key(self): if hasattr(self, '_m_has_field_right_space_openness_rtpc_key'): return self._m_has_field_right_space_openness_rtpc_key self._m_has_field_right_space_openness_rtpc_key = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_right_space_openness_rtpc_key', None) @property def has_field_cone_angle(self): if hasattr(self, '_m_has_field_cone_angle'): return self._m_has_field_cone_angle self._m_has_field_cone_angle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_cone_angle', None) class ConfigRegionalPlayMichiaeMatsuri(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigRegionalPlayBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dark_pressure_sgv: self.dark_pressure_sgv = AuxTypes.String(self._io, self, self._root) if self.has_field_crystal_energy_sgv: self.crystal_energy_sgv = AuxTypes.String(self._io, self, self._root) if self.has_field_offering_id: self.offering_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_crystal_level_sgv: self.crystal_level_sgv = AuxTypes.String(self._io, self, self._root) @property def has_field_offering_id(self): if hasattr(self, '_m_has_field_offering_id'): return self._m_has_field_offering_id self._m_has_field_offering_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_offering_id', None) @property def is_team(self): if hasattr(self, '_m_is_team'): return self._m_is_team self._m_is_team = self.base.is_team return getattr(self, '_m_is_team', None) @property def var_list(self): if hasattr(self, '_m_var_list'): return self._m_var_list self._m_var_list = self.base.var_list return getattr(self, '_m_var_list', None) @property def has_field_dark_pressure_sgv(self): if hasattr(self, '_m_has_field_dark_pressure_sgv'): return self._m_has_field_dark_pressure_sgv self._m_has_field_dark_pressure_sgv = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dark_pressure_sgv', None) @property def bind_scene(self): if hasattr(self, '_m_bind_scene'): return self._m_bind_scene self._m_bind_scene = self.base.bind_scene return getattr(self, '_m_bind_scene', None) @property def ability_group_name_list(self): if hasattr(self, '_m_ability_group_name_list'): return self._m_ability_group_name_list self._m_ability_group_name_list = self.base.ability_group_name_list return getattr(self, '_m_ability_group_name_list', None) @property def has_field_crystal_energy_sgv(self): if hasattr(self, '_m_has_field_crystal_energy_sgv'): return self._m_has_field_crystal_energy_sgv self._m_has_field_crystal_energy_sgv = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_crystal_energy_sgv', None) @property def has_field_crystal_level_sgv(self): if hasattr(self, '_m_has_field_crystal_level_sgv'): return self._m_has_field_crystal_level_sgv self._m_has_field_crystal_level_sgv = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_crystal_level_sgv', None) @property def play_type(self): if hasattr(self, '_m_play_type'): return self._m_play_type self._m_play_type = self.base.play_type return getattr(self, '_m_play_type', None) class ConfigMoveSmoothedSpeed(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_speed: self.max_speed = self._io.read_f4le() if self.has_field_acceleration_xz: self.acceleration_xz = self._io.read_f4le() if self.has_field_acceleration_y: self.acceleration_y = self._io.read_f4le() if self.has_field_zeroing_speed_xz: self.zeroing_speed_xz = self._io.read_f4le() if self.has_field_zeroing_speed_y: self.zeroing_speed_y = self._io.read_f4le() @property def has_field_max_speed(self): if hasattr(self, '_m_has_field_max_speed'): return self._m_has_field_max_speed self._m_has_field_max_speed = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_speed', None) @property def has_field_acceleration_y(self): if hasattr(self, '_m_has_field_acceleration_y'): return self._m_has_field_acceleration_y self._m_has_field_acceleration_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_acceleration_y', None) @property def has_field_acceleration_xz(self): if hasattr(self, '_m_has_field_acceleration_xz'): return self._m_has_field_acceleration_xz self._m_has_field_acceleration_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_acceleration_xz', None) @property def has_field_zeroing_speed_xz(self): if hasattr(self, '_m_has_field_zeroing_speed_xz'): return self._m_has_field_zeroing_speed_xz self._m_has_field_zeroing_speed_xz = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_zeroing_speed_xz', None) @property def has_field_zeroing_speed_y(self): if hasattr(self, '_m_has_field_zeroing_speed_y'): return self._m_has_field_zeroing_speed_y self._m_has_field_zeroing_speed_y = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_zeroing_speed_y', None) class EnumMaskGuideType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MaskGuideType, self.data.value) return getattr(self, '_m_value', None) class BattlePassStoryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PsActivitiesSubTaskConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hidden: self.hidden = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_object_id: self.object_id = AuxTypes.String(self._io, self, self._root) if self.has_field_export_version: self.export_version = AuxTypes.String(self._io, self, self._root) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_task_id', None) @property def has_field_export_version(self): if hasattr(self, '_m_has_field_export_version'): return self._m_has_field_export_version self._m_has_field_export_version = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_export_version', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_object_id(self): if hasattr(self, '_m_has_field_object_id'): return self._m_has_field_object_id self._m_has_field_object_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_object_id', None) @property def has_field_hidden(self): if hasattr(self, '_m_has_field_hidden'): return self._m_has_field_hidden self._m_has_field_hidden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_hidden', None) class ActivityIslandPartyScoreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score: self.score = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_score(self): if hasattr(self, '_m_has_field_score'): return self._m_has_field_score self._m_has_field_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_score', None) class DungeonRosterCycleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomSectionOrderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumAiTargetSystemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AiTargetSystemType, self.data.value) return getattr(self, '_m_value', None) class StartDither(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_reverse: self.reverse = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_reverse(self): if hasattr(self, '_m_has_field_reverse'): return self._m_has_field_reverse self._m_has_field_reverse = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reverse', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumEntityMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EntityMarkType, self.data.value) return getattr(self, '_m_value', None) class PointLocationComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MarkIconTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFetterCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FetterCondType, self.data.value) return getattr(self, '_m_value', None) class EnumCameraShakeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CameraShakeType, self.data.value) return getattr(self, '_m_value', None) class ByTargetForwardAndSelfPosition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_is_xz: self.is_xz = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_xz(self): if hasattr(self, '_m_has_field_is_xz'): return self._m_has_field_is_xz self._m_has_field_is_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_xz', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ReliquaryDecomposeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoundRandomTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispSelectTargets(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.SelectTargets(self._io, self, self._root) elif _on == 4: self.data = Output.SelectTargetsByChildrenEntityType(self._io, self, self._root) elif _on == 6: self.data = Output.SelectTargetsBySelfGroup(self._io, self, self._root) elif _on == 7: self.data = Output.SelectTargetsByLcTrigger(self._io, self, self._root) elif _on == 1: self.data = Output.SelectTargetsByShape(self._io, self, self._root) elif _on == 3: self.data = Output.SelectTargetsByChildren(self._io, self, self._root) elif _on == 5: self.data = Output.SelectTargetsByTag(self._io, self, self._root) elif _on == 8: self.data = Output.SelectTargetsByLcTriggerAll(self._io, self, self._root) elif _on == 2: self.data = Output.SelectTargetsByEquipParts(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivitySalesmanDailyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_daily_config_id: self.daily_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_item_list: self.cost_item_list = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_clus_pos: self.clus_pos = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_talk: self.npc_talk = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro: self.intro = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trace_position: self.trace_position = AuxTypes.String(self._io, self, self._root) @property def has_field_daily_config_id(self): if hasattr(self, '_m_has_field_daily_config_id'): return self._m_has_field_daily_config_id self._m_has_field_daily_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_daily_config_id', None) @property def has_field_trace_position(self): if hasattr(self, '_m_has_field_trace_position'): return self._m_has_field_trace_position self._m_has_field_trace_position = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_trace_position', None) @property def has_field_clus_pos(self): if hasattr(self, '_m_has_field_clus_pos'): return self._m_has_field_clus_pos self._m_has_field_clus_pos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_clus_pos', None) @property def has_field_intro(self): if hasattr(self, '_m_has_field_intro'): return self._m_has_field_intro self._m_has_field_intro = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_intro', None) @property def has_field_cost_item_list(self): if hasattr(self, '_m_has_field_cost_item_list'): return self._m_has_field_cost_item_list self._m_has_field_cost_item_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cost_item_list', None) @property def has_field_npc_talk(self): if hasattr(self, '_m_has_field_npc_talk'): return self._m_has_field_npc_talk self._m_has_field_npc_talk = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_npc_talk', None) class ReunionScheduleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlayTextDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_landing_angle_max: self.landing_angle_max = self._io.read_f4le() if self.has_field_landing_angle_min: self.landing_angle_min = self._io.read_f4le() if self.has_field_landing_terrain_altitude: self.landing_terrain_altitude = self._io.read_f4le() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_landing_angle_max(self): if hasattr(self, '_m_has_field_landing_angle_max'): return self._m_has_field_landing_angle_max self._m_has_field_landing_angle_max = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_landing_angle_max', None) @property def has_field_landing_angle_min(self): if hasattr(self, '_m_has_field_landing_angle_min'): return self._m_has_field_landing_angle_min self._m_has_field_landing_angle_min = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_landing_angle_min', None) @property def has_field_landing_terrain_altitude(self): if hasattr(self, '_m_has_field_landing_terrain_altitude'): return self._m_has_field_landing_terrain_altitude self._m_has_field_landing_terrain_altitude = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_landing_terrain_altitude', None) class ConfigConstForceField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigForceField(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_velocity: self.velocity = self._io.read_f4le() @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_velocity(self): if hasattr(self, '_m_has_field_velocity'): return self._m_has_field_velocity self._m_has_field_velocity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_velocity', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class AsterStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_name: self.stage_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_openday: self.openday = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_quest_id: self.open_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro: self.intro = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story: self.story = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_score: self.unlock_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id_list: self.quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_story(self): if hasattr(self, '_m_has_field_story'): return self._m_has_field_story self._m_has_field_story = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_story', None) @property def has_field_intro(self): if hasattr(self, '_m_has_field_intro'): return self._m_has_field_intro self._m_has_field_intro = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_intro', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_open_quest_id(self): if hasattr(self, '_m_has_field_open_quest_id'): return self._m_has_field_open_quest_id self._m_has_field_open_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_open_quest_id', None) @property def has_field_unlock_score(self): if hasattr(self, '_m_has_field_unlock_score'): return self._m_has_field_unlock_score self._m_has_field_unlock_score = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_unlock_score', None) @property def has_field_quest_id_list(self): if hasattr(self, '_m_has_field_quest_id_list'): return self._m_has_field_quest_id_list self._m_has_field_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_quest_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_stage_name(self): if hasattr(self, '_m_has_field_stage_name'): return self._m_has_field_stage_name self._m_has_field_stage_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_stage_name', None) @property def has_field_openday(self): if hasattr(self, '_m_has_field_openday'): return self._m_has_field_openday self._m_has_field_openday = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_openday', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class WinterCampBattleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_link_id: self.group_link_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_index: self.challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_group_link_id(self): if hasattr(self, '_m_has_field_group_link_id'): return self._m_has_field_group_link_id self._m_has_field_group_link_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_link_id', None) @property def has_field_challenge_index(self): if hasattr(self, '_m_has_field_challenge_index'): return self._m_has_field_challenge_index self._m_has_field_challenge_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_challenge_index', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) class ArrayOfSectrPlatformStreamLayerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrPlatformStreamLayer(self._io, self, self._root)) class FurnitureDeploySurfaceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDragonSpineMissionFinishConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DragonSpineMissionFinishConfig(self._io, self, self._root)) class FadeTintQualityLevelComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumPlayModeTypeConfigActionPanelMode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPlayModeTypeConfigActionPanelMode(self._io, self, self._root)) class RogueDiaryCardWeightExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sr_count: self.sr_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_retry_weight: self.retry_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sr_count(self): if hasattr(self, '_m_has_field_sr_count'): return self._m_has_field_sr_count self._m_has_field_sr_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sr_count', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_retry_weight(self): if hasattr(self, '_m_has_field_retry_weight'): return self._m_has_field_retry_weight self._m_has_field_retry_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_retry_weight', None) class EffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UseItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_num: self.item_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_item_num(self): if hasattr(self, '_m_has_field_item_num'): return self._m_has_field_item_num self._m_has_field_item_num = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_item_num', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SetAiHitFeeling(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringConfigGraphicsRecommendSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigGraphicsRecommendSetting(self._io, self, self._root) class ConfigClimatePerform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_chance: self.chance = self._io.read_f4le() if self.has_field_perform_triggers: self.perform_triggers = Output.DictOfEnumJsonClimateTypeAuxTypesString(self._io, self, self._root) @property def has_field_chance(self): if hasattr(self, '_m_has_field_chance'): return self._m_has_field_chance self._m_has_field_chance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_chance', None) @property def has_field_perform_triggers(self): if hasattr(self, '_m_has_field_perform_triggers'): return self._m_has_field_perform_triggers self._m_has_field_perform_triggers = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_perform_triggers', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSpacialWanderData(self._io, self, self._root) class FloatNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ActivityPotionDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MainPageUiDisableTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDirectionByGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_direction_key: self.direction_key = AuxTypes.String(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def has_field_direction_key(self): if hasattr(self, '_m_has_field_direction_key'): return self._m_has_field_direction_key self._m_has_field_direction_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_direction_key', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class AuxObjectEntry(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumElementTypeConfigElementShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementType(self._io, self, self._root) self.value = Output.ConfigElementShieldResistance(self._io, self, self._root) class ExploreAreaTotalExpExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigAttachment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAttachment(self._io, self, self._root)) class ConfigMusicStringPresenceStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicStringMultiValueStimulusHandler(self._io, self, self._root) @property def string_params(self): if hasattr(self, '_m_string_params'): return self._m_string_params self._m_string_params = self.base.string_params return getattr(self, '_m_string_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class SelectTargetsByChildren(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class ShowQuestGuideTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioVoiceTriggerComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CombineUnlockConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_unlock_method: self.unlock_method = Output.EnumCombineUnlockMethod(self._io, self, self._root) if self.has_field_unlock_param: self.unlock_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_unlock_method(self): if hasattr(self, '_m_has_field_unlock_method'): return self._m_has_field_unlock_method self._m_has_field_unlock_method = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_unlock_method', None) @property def has_field_unlock_param(self): if hasattr(self, '_m_has_field_unlock_param'): return self._m_has_field_unlock_param self._m_has_field_unlock_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_unlock_param', None) class TowerBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityShopSheetExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_ahead_preview: self.is_ahead_preview = self._io.read_u1() if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_sheet_name: self.sheet_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfActivityShopSheetCondLengthS(self._io, self, self._root) if self.has_field_sort_level: self.sort_level = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_is_ahead_preview(self): if hasattr(self, '_m_has_field_is_ahead_preview'): return self._m_has_field_is_ahead_preview self._m_has_field_is_ahead_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_ahead_preview', None) @property def has_field_sort_level(self): if hasattr(self, '_m_has_field_sort_level'): return self._m_has_field_sort_level self._m_has_field_sort_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_sort_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_sheet_name(self): if hasattr(self, '_m_has_field_sheet_name'): return self._m_has_field_sheet_name self._m_has_field_sheet_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sheet_name', None) class ConfigMultiBullet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_select_target_default_type: self.select_target_default_type = Output.EnumSelectTargetDefaultType(self._io, self, self._root) @property def has_field_select_target_default_type(self): if hasattr(self, '_m_has_field_select_target_default_type'): return self._m_has_field_select_target_default_type self._m_has_field_select_target_default_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_select_target_default_type', None) class ConfigGuideSwitchInputContextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_input_event_list: self.input_event_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_context_event_list: self.context_event_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_input_priority_list: self.input_priority_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_input_event_list(self): if hasattr(self, '_m_has_field_input_event_list'): return self._m_has_field_input_event_list self._m_has_field_input_event_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_input_event_list', None) @property def has_field_context_event_list(self): if hasattr(self, '_m_has_field_context_event_list'): return self._m_has_field_context_event_list self._m_has_field_context_event_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_context_event_list', None) @property def has_field_input_priority_list(self): if hasattr(self, '_m_has_field_input_priority_list'): return self._m_has_field_input_priority_list self._m_has_field_input_priority_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_input_priority_list', None) class DamageAttackerComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoguelikeShikigamiUnlockConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRoguelikeShikigamiUnlockType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class DocumentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityChessCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfStringKeyItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfStringKeyItemOptionArrayInfo(self._io, self, self._root)) class AttachModifierToPredicateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumAvatarStageType(self._io, self, self._root) if self.has_field_on_event: self.on_event = Output.EnumOnEventType(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_on_ability_state_added: self.on_ability_state_added = Output.ArrayOfConfigAbilityStateToActionsLengthU(self._io, self, self._root) if self.has_field_on_ability_state_removed: self.on_ability_state_removed = Output.ArrayOfConfigAbilityStateToActionsLengthU(self._io, self, self._root) @property def has_field_on_event(self): if hasattr(self, '_m_has_field_on_event'): return self._m_has_field_on_event self._m_has_field_on_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_event', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_on_ability_state_added(self): if hasattr(self, '_m_has_field_on_ability_state_added'): return self._m_has_field_on_ability_state_added self._m_has_field_on_ability_state_added = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_on_ability_state_added', None) @property def has_field_on_ability_state_removed(self): if hasattr(self, '_m_has_field_on_ability_state_removed'): return self._m_has_field_on_ability_state_removed self._m_has_field_on_ability_state_removed = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_on_ability_state_removed', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class SubTokenPreProcess(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_sub_tokens_to_pre_process: self.sub_tokens_to_pre_process = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_sub_tokens_to_pre_process(self): if hasattr(self, '_m_has_field_sub_tokens_to_pre_process'): return self._m_has_field_sub_tokens_to_pre_process self._m_has_field_sub_tokens_to_pre_process = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sub_tokens_to_pre_process', None) class NativeTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandomQuestCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class AudioOneTimeEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_event_name: self.event_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_duration: self.duration = self._io.read_f4le() @property def has_field_event_name(self): if hasattr(self, '_m_has_field_event_name'): return self._m_has_field_event_name self._m_has_field_event_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_event_name', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) class BlackScreenTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeUF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = self._io.read_f4le() class EnumAssocType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AssocType, self.data.value) return getattr(self, '_m_value', None) class SceneObjStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBaseGadgetTriggerAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InputValueTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRandomQuestFilterType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RandomQuestFilterType, self.data.value) return getattr(self, '_m_value', None) class ConfigControllerSubs(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_path: self.path = AuxTypes.String(self._io, self, self._root) if self.has_field_subs_name: self.subs_name = AuxTypes.String(self._io, self, self._root) if self.has_field_state_i_ds: self.state_i_ds = Output.DictOfAuxTypesStringDispConfigBaseStateIdInfo(self._io, self, self._root) @property def has_field_path(self): if hasattr(self, '_m_has_field_path'): return self._m_has_field_path self._m_has_field_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_path', None) @property def has_field_subs_name(self): if hasattr(self, '_m_has_field_subs_name'): return self._m_has_field_subs_name self._m_has_field_subs_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_subs_name', None) @property def has_field_state_i_ds(self): if hasattr(self, '_m_has_field_state_i_ds'): return self._m_has_field_state_i_ds self._m_has_field_state_i_ds = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_state_i_ds', None) class ConfigLinerParabolaBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLinerBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_straight_range: self.straight_range = self._io.read_f4le() if self.has_field_gravity_of_acceleration: self.gravity_of_acceleration = self._io.read_f4le() if self.has_field_air_resistance: self.air_resistance = self._io.read_f4le() @property def has_field_air_resistance(self): if hasattr(self, '_m_has_field_air_resistance'): return self._m_has_field_air_resistance self._m_has_field_air_resistance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_air_resistance', None) @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def has_field_straight_range(self): if hasattr(self, '_m_has_field_straight_range'): return self._m_has_field_straight_range self._m_has_field_straight_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_straight_range', None) @property def has_field_gravity_of_acceleration(self): if hasattr(self, '_m_has_field_gravity_of_acceleration'): return self._m_has_field_gravity_of_acceleration self._m_has_field_gravity_of_acceleration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_gravity_of_acceleration', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class BartenderTaskOrderExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_id: self.order_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_content_param: self.content_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dialog_id_succ: self.dialog_id_succ = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dialog_id_fail: self.dialog_id_fail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_guide_quest: self.is_guide_quest = self._io.read_u1() if self.has_field_next_quest_id: self.next_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_order_id(self): if hasattr(self, '_m_has_field_order_id'): return self._m_has_field_order_id self._m_has_field_order_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order_id', None) @property def has_field_content_param(self): if hasattr(self, '_m_has_field_content_param'): return self._m_has_field_content_param self._m_has_field_content_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_content_param', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_is_guide_quest(self): if hasattr(self, '_m_has_field_is_guide_quest'): return self._m_has_field_is_guide_quest self._m_has_field_is_guide_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_guide_quest', None) @property def has_field_dialog_id_succ(self): if hasattr(self, '_m_has_field_dialog_id_succ'): return self._m_has_field_dialog_id_succ self._m_has_field_dialog_id_succ = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dialog_id_succ', None) @property def has_field_next_quest_id(self): if hasattr(self, '_m_has_field_next_quest_id'): return self._m_has_field_next_quest_id self._m_has_field_next_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_next_quest_id', None) @property def has_field_dialog_id_fail(self): if hasattr(self, '_m_has_field_dialog_id_fail'): return self._m_has_field_dialog_id_fail self._m_has_field_dialog_id_fail = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_dialog_id_fail', None) class DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root)) class DungeonElementChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioUi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_support: self.support = Output.AudioUiSupport(self._io, self, self._root) if self.has_field_equip: self.equip = Output.AudioUiEquip(self._io, self, self._root) if self.has_field_open_chest_event: self.open_chest_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_join_team_event: self.join_team_event = Output.AudioOneTimeEvent(self._io, self, self._root) if self.has_field_element_state_key: self.element_state_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_element_state_default_value: self.element_state_default_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_element_state_value_map: self.element_state_value_map = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_character_appear_event: self.character_appear_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_add_map_pin_event: self.add_map_pin_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_remove_map_pin_event: self.remove_map_pin_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enable_element_view_event: self.enable_element_view_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_disable_element_view_event: self.disable_element_view_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dungeon_victory_event: self.dungeon_victory_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dungeon_defeat_event: self.dungeon_defeat_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_change_weapon_event: self.change_weapon_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_wear_relic_event: self.wear_relic_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_takeoff_relic_event: self.takeoff_relic_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_select_avatar_relic_event: self.select_avatar_relic_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_add_equip_material_event: self.add_equip_material_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_talent_unlock_event: self.talent_unlock_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_change_avatar_success_event: self.change_avatar_success_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_change_avatar_failed_event: self.change_avatar_failed_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_select_main_quest_event: self.select_main_quest_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_team_avatar_hold_up: self.team_avatar_hold_up = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_team_avatar_hold_down: self.team_avatar_hold_down = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_team_avatar_click: self.team_avatar_click = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_bag_drop_item: self.bag_drop_item = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_mail_delete_event: self.mail_delete_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_item_in_cd_event: self.item_in_cd_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_pick_up_event: self.pick_up_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_player_level_btn_event: self.player_level_btn_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_chest_pickup_fail_event: self.chest_pickup_fail_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enter_dungeon_success_event: self.enter_dungeon_success_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_open_page_default_event: self.open_page_default_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_close_page_default_event: self.close_page_default_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_open_page_custom_events: self.open_page_custom_events = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) if self.has_field_close_page_custom_events: self.close_page_custom_events = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) if self.has_field_video_start_default_event: self.video_start_default_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_video_end_default_event: self.video_end_default_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_video_start_custom_events: self.video_start_custom_events = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) if self.has_field_video_end_custom_events: self.video_end_custom_events = Output.DictOfAuxTypesStringConfigWwiseString(self._io, self, self._root) if self.has_field_default_enable_delay_count: self.default_enable_delay_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_character_select_music_end_event: self.character_select_music_end_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_loading_events_map: self.loading_events_map = Output.DictOfAuxTypesVlqBase128LeSConfigWwiseString(self._io, self, self._root) @property def has_field_wear_relic_event(self): if hasattr(self, '_m_has_field_wear_relic_event'): return self._m_has_field_wear_relic_event self._m_has_field_wear_relic_event = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_wear_relic_event', None) @property def has_field_team_avatar_hold_up(self): if hasattr(self, '_m_has_field_team_avatar_hold_up'): return self._m_has_field_team_avatar_hold_up self._m_has_field_team_avatar_hold_up = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_team_avatar_hold_up', None) @property def has_field_enable_element_view_event(self): if hasattr(self, '_m_has_field_enable_element_view_event'): return self._m_has_field_enable_element_view_event self._m_has_field_enable_element_view_event = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_enable_element_view_event', None) @property def has_field_add_equip_material_event(self): if hasattr(self, '_m_has_field_add_equip_material_event'): return self._m_has_field_add_equip_material_event self._m_has_field_add_equip_material_event = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_add_equip_material_event', None) @property def has_field_item_in_cd_event(self): if hasattr(self, '_m_has_field_item_in_cd_event'): return self._m_has_field_item_in_cd_event self._m_has_field_item_in_cd_event = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_item_in_cd_event', None) @property def has_field_default_enable_delay_count(self): if hasattr(self, '_m_has_field_default_enable_delay_count'): return self._m_has_field_default_enable_delay_count self._m_has_field_default_enable_delay_count = (self.bit_field.value & 2199023255552) != 0 return getattr(self, '_m_has_field_default_enable_delay_count', None) @property def has_field_loading_events_map(self): if hasattr(self, '_m_has_field_loading_events_map'): return self._m_has_field_loading_events_map self._m_has_field_loading_events_map = (self.bit_field.value & 8796093022208) != 0 return getattr(self, '_m_has_field_loading_events_map', None) @property def has_field_remove_map_pin_event(self): if hasattr(self, '_m_has_field_remove_map_pin_event'): return self._m_has_field_remove_map_pin_event self._m_has_field_remove_map_pin_event = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_remove_map_pin_event', None) @property def has_field_support(self): if hasattr(self, '_m_has_field_support'): return self._m_has_field_support self._m_has_field_support = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_support', None) @property def has_field_player_level_btn_event(self): if hasattr(self, '_m_has_field_player_level_btn_event'): return self._m_has_field_player_level_btn_event self._m_has_field_player_level_btn_event = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_player_level_btn_event', None) @property def has_field_chest_pickup_fail_event(self): if hasattr(self, '_m_has_field_chest_pickup_fail_event'): return self._m_has_field_chest_pickup_fail_event self._m_has_field_chest_pickup_fail_event = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_chest_pickup_fail_event', None) @property def has_field_video_end_default_event(self): if hasattr(self, '_m_has_field_video_end_default_event'): return self._m_has_field_video_end_default_event self._m_has_field_video_end_default_event = (self.bit_field.value & 274877906944) != 0 return getattr(self, '_m_has_field_video_end_default_event', None) @property def has_field_video_start_default_event(self): if hasattr(self, '_m_has_field_video_start_default_event'): return self._m_has_field_video_start_default_event self._m_has_field_video_start_default_event = (self.bit_field.value & 137438953472) != 0 return getattr(self, '_m_has_field_video_start_default_event', None) @property def has_field_select_main_quest_event(self): if hasattr(self, '_m_has_field_select_main_quest_event'): return self._m_has_field_select_main_quest_event self._m_has_field_select_main_quest_event = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_select_main_quest_event', None) @property def has_field_bag_drop_item(self): if hasattr(self, '_m_has_field_bag_drop_item'): return self._m_has_field_bag_drop_item self._m_has_field_bag_drop_item = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_bag_drop_item', None) @property def has_field_mail_delete_event(self): if hasattr(self, '_m_has_field_mail_delete_event'): return self._m_has_field_mail_delete_event self._m_has_field_mail_delete_event = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_mail_delete_event', None) @property def has_field_character_select_music_end_event(self): if hasattr(self, '_m_has_field_character_select_music_end_event'): return self._m_has_field_character_select_music_end_event self._m_has_field_character_select_music_end_event = (self.bit_field.value & 4398046511104) != 0 return getattr(self, '_m_has_field_character_select_music_end_event', None) @property def has_field_dungeon_victory_event(self): if hasattr(self, '_m_has_field_dungeon_victory_event'): return self._m_has_field_dungeon_victory_event self._m_has_field_dungeon_victory_event = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_dungeon_victory_event', None) @property def has_field_talent_unlock_event(self): if hasattr(self, '_m_has_field_talent_unlock_event'): return self._m_has_field_talent_unlock_event self._m_has_field_talent_unlock_event = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_talent_unlock_event', None) @property def has_field_close_page_custom_events(self): if hasattr(self, '_m_has_field_close_page_custom_events'): return self._m_has_field_close_page_custom_events self._m_has_field_close_page_custom_events = (self.bit_field.value & 68719476736) != 0 return getattr(self, '_m_has_field_close_page_custom_events', None) @property def has_field_element_state_key(self): if hasattr(self, '_m_has_field_element_state_key'): return self._m_has_field_element_state_key self._m_has_field_element_state_key = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_element_state_key', None) @property def has_field_element_state_value_map(self): if hasattr(self, '_m_has_field_element_state_value_map'): return self._m_has_field_element_state_value_map self._m_has_field_element_state_value_map = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_element_state_value_map', None) @property def has_field_video_start_custom_events(self): if hasattr(self, '_m_has_field_video_start_custom_events'): return self._m_has_field_video_start_custom_events self._m_has_field_video_start_custom_events = (self.bit_field.value & 549755813888) != 0 return getattr(self, '_m_has_field_video_start_custom_events', None) @property def has_field_disable_element_view_event(self): if hasattr(self, '_m_has_field_disable_element_view_event'): return self._m_has_field_disable_element_view_event self._m_has_field_disable_element_view_event = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_disable_element_view_event', None) @property def has_field_join_team_event(self): if hasattr(self, '_m_has_field_join_team_event'): return self._m_has_field_join_team_event self._m_has_field_join_team_event = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_join_team_event', None) @property def has_field_takeoff_relic_event(self): if hasattr(self, '_m_has_field_takeoff_relic_event'): return self._m_has_field_takeoff_relic_event self._m_has_field_takeoff_relic_event = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_takeoff_relic_event', None) @property def has_field_open_page_custom_events(self): if hasattr(self, '_m_has_field_open_page_custom_events'): return self._m_has_field_open_page_custom_events self._m_has_field_open_page_custom_events = (self.bit_field.value & 34359738368) != 0 return getattr(self, '_m_has_field_open_page_custom_events', None) @property def has_field_equip(self): if hasattr(self, '_m_has_field_equip'): return self._m_has_field_equip self._m_has_field_equip = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_equip', None) @property def has_field_open_page_default_event(self): if hasattr(self, '_m_has_field_open_page_default_event'): return self._m_has_field_open_page_default_event self._m_has_field_open_page_default_event = (self.bit_field.value & 8589934592) != 0 return getattr(self, '_m_has_field_open_page_default_event', None) @property def has_field_close_page_default_event(self): if hasattr(self, '_m_has_field_close_page_default_event'): return self._m_has_field_close_page_default_event self._m_has_field_close_page_default_event = (self.bit_field.value & 17179869184) != 0 return getattr(self, '_m_has_field_close_page_default_event', None) @property def has_field_dungeon_defeat_event(self): if hasattr(self, '_m_has_field_dungeon_defeat_event'): return self._m_has_field_dungeon_defeat_event self._m_has_field_dungeon_defeat_event = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_dungeon_defeat_event', None) @property def has_field_video_end_custom_events(self): if hasattr(self, '_m_has_field_video_end_custom_events'): return self._m_has_field_video_end_custom_events self._m_has_field_video_end_custom_events = (self.bit_field.value & 1099511627776) != 0 return getattr(self, '_m_has_field_video_end_custom_events', None) @property def has_field_pick_up_event(self): if hasattr(self, '_m_has_field_pick_up_event'): return self._m_has_field_pick_up_event self._m_has_field_pick_up_event = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_pick_up_event', None) @property def has_field_change_avatar_success_event(self): if hasattr(self, '_m_has_field_change_avatar_success_event'): return self._m_has_field_change_avatar_success_event self._m_has_field_change_avatar_success_event = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_change_avatar_success_event', None) @property def has_field_open_chest_event(self): if hasattr(self, '_m_has_field_open_chest_event'): return self._m_has_field_open_chest_event self._m_has_field_open_chest_event = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_open_chest_event', None) @property def has_field_add_map_pin_event(self): if hasattr(self, '_m_has_field_add_map_pin_event'): return self._m_has_field_add_map_pin_event self._m_has_field_add_map_pin_event = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_add_map_pin_event', None) @property def has_field_character_appear_event(self): if hasattr(self, '_m_has_field_character_appear_event'): return self._m_has_field_character_appear_event self._m_has_field_character_appear_event = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_character_appear_event', None) @property def has_field_enter_dungeon_success_event(self): if hasattr(self, '_m_has_field_enter_dungeon_success_event'): return self._m_has_field_enter_dungeon_success_event self._m_has_field_enter_dungeon_success_event = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_enter_dungeon_success_event', None) @property def has_field_element_state_default_value(self): if hasattr(self, '_m_has_field_element_state_default_value'): return self._m_has_field_element_state_default_value self._m_has_field_element_state_default_value = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_element_state_default_value', None) @property def has_field_change_weapon_event(self): if hasattr(self, '_m_has_field_change_weapon_event'): return self._m_has_field_change_weapon_event self._m_has_field_change_weapon_event = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_change_weapon_event', None) @property def has_field_select_avatar_relic_event(self): if hasattr(self, '_m_has_field_select_avatar_relic_event'): return self._m_has_field_select_avatar_relic_event self._m_has_field_select_avatar_relic_event = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_select_avatar_relic_event', None) @property def has_field_team_avatar_click(self): if hasattr(self, '_m_has_field_team_avatar_click'): return self._m_has_field_team_avatar_click self._m_has_field_team_avatar_click = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_team_avatar_click', None) @property def has_field_change_avatar_failed_event(self): if hasattr(self, '_m_has_field_change_avatar_failed_event'): return self._m_has_field_change_avatar_failed_event self._m_has_field_change_avatar_failed_event = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_change_avatar_failed_event', None) @property def has_field_team_avatar_hold_down(self): if hasattr(self, '_m_has_field_team_avatar_hold_down'): return self._m_has_field_team_avatar_hold_down self._m_has_field_team_avatar_hold_down = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_team_avatar_hold_down', None) class ConfigSpecificFloatValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_value: self.default_value = self._io.read_f4le() if self.has_field_specific_value: self.specific_value = Output.DictOfAuxTypesStringF4(self._io, self, self._root) @property def has_field_default_value(self): if hasattr(self, '_m_has_field_default_value'): return self._m_has_field_default_value self._m_has_field_default_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_value', None) @property def has_field_specific_value(self): if hasattr(self, '_m_has_field_specific_value'): return self._m_has_field_specific_value self._m_has_field_specific_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specific_value', None) class EnumDontDestroyOnLoadType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DontDestroyOnLoadType, self.data.value) return getattr(self, '_m_value', None) class ConfigEmojiBubbleAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_pattarn_name: self.pattarn_name = AuxTypes.String(self._io, self, self._root) if self.has_field_try_stop: self.try_stop = self._io.read_u1() @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_pattarn_name(self): if hasattr(self, '_m_has_field_pattarn_name'): return self._m_has_field_pattarn_name self._m_has_field_pattarn_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pattarn_name', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_try_stop(self): if hasattr(self, '_m_has_field_try_stop'): return self._m_has_field_try_stop self._m_has_field_try_stop = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_try_stop', None) class DungeonPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDirectionByEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class AbilityPropExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByWidgetExCdReady(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class QuestGuideTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigLevelPolygonTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigLevelPolygonTag, self.data.value) return getattr(self, '_m_value', None) class DragonSpinePreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumForgeUnlockMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ForgeUnlockMethod, self.data.value) return getattr(self, '_m_value', None) class DiePatternSwitchMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = Output.EnumDiePatternSwitchMixinPriority(self._io, self, self._root) if self.has_field_has_animator_die: self.has_animator_die = self._io.read_u1() if self.has_field_mute_all_shader_die_eff: self.mute_all_shader_die_eff = self._io.read_u1() if self.has_field_fall_when_air_die: self.fall_when_air_die = self._io.read_u1() if self.has_field_die_end_time: self.die_end_time = self._io.read_f4le() if self.has_field_die_force_disappear_time: self.die_force_disappear_time = self._io.read_f4le() if self.has_field_die_disappear_effect: self.die_disappear_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_die_disappear_effect_delay: self.die_disappear_effect_delay = self._io.read_f4le() if self.has_field_die_shader_data: self.die_shader_data = Output.EnumEShaderData(self._io, self, self._root) if self.has_field_die_shader_enable_duration_time: self.die_shader_enable_duration_time = self._io.read_f4le() if self.has_field_die_shader_disable_duration_time: self.die_shader_disable_duration_time = self._io.read_f4le() if self.has_field_die_model_fade_delay: self.die_model_fade_delay = self._io.read_f4le() if self.has_field_rag_doll_die_end_time_delay: self.rag_doll_die_end_time_delay = self._io.read_f4le() if self.has_field_start_die_end_at_once: self.start_die_end_at_once = self._io.read_u1() if self.has_field_not_send_die_trigger: self.not_send_die_trigger = self._io.read_u1() if self.has_field_ignore_element_die: self.ignore_element_die = self._io.read_u1() if self.has_field_mute_hit_box: self.mute_hit_box = self._io.read_u1() if self.has_field_die_deny_lock_on: self.die_deny_lock_on = self._io.read_u1() if self.has_field_die_is_ghost_to_enemy: self.die_is_ghost_to_enemy = self._io.read_u1() if self.has_field_die_ignore_trigger_bullet: self.die_ignore_trigger_bullet = self._io.read_u1() if self.has_field_mute_billboard: self.mute_billboard = self._io.read_u1() if self.has_field_mute_push_collider: self.mute_push_collider = self._io.read_u1() @property def has_field_die_model_fade_delay(self): if hasattr(self, '_m_has_field_die_model_fade_delay'): return self._m_has_field_die_model_fade_delay self._m_has_field_die_model_fade_delay = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_die_model_fade_delay', None) @property def has_field_die_deny_lock_on(self): if hasattr(self, '_m_has_field_die_deny_lock_on'): return self._m_has_field_die_deny_lock_on self._m_has_field_die_deny_lock_on = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_die_deny_lock_on', None) @property def has_field_die_is_ghost_to_enemy(self): if hasattr(self, '_m_has_field_die_is_ghost_to_enemy'): return self._m_has_field_die_is_ghost_to_enemy self._m_has_field_die_is_ghost_to_enemy = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_die_is_ghost_to_enemy', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_die_shader_enable_duration_time(self): if hasattr(self, '_m_has_field_die_shader_enable_duration_time'): return self._m_has_field_die_shader_enable_duration_time self._m_has_field_die_shader_enable_duration_time = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_die_shader_enable_duration_time', None) @property def has_field_die_shader_disable_duration_time(self): if hasattr(self, '_m_has_field_die_shader_disable_duration_time'): return self._m_has_field_die_shader_disable_duration_time self._m_has_field_die_shader_disable_duration_time = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_die_shader_disable_duration_time', None) @property def has_field_start_die_end_at_once(self): if hasattr(self, '_m_has_field_start_die_end_at_once'): return self._m_has_field_start_die_end_at_once self._m_has_field_start_die_end_at_once = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_start_die_end_at_once', None) @property def has_field_die_force_disappear_time(self): if hasattr(self, '_m_has_field_die_force_disappear_time'): return self._m_has_field_die_force_disappear_time self._m_has_field_die_force_disappear_time = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_die_force_disappear_time', None) @property def has_field_not_send_die_trigger(self): if hasattr(self, '_m_has_field_not_send_die_trigger'): return self._m_has_field_not_send_die_trigger self._m_has_field_not_send_die_trigger = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_not_send_die_trigger', None) @property def has_field_has_animator_die(self): if hasattr(self, '_m_has_field_has_animator_die'): return self._m_has_field_has_animator_die self._m_has_field_has_animator_die = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_has_animator_die', None) @property def has_field_die_ignore_trigger_bullet(self): if hasattr(self, '_m_has_field_die_ignore_trigger_bullet'): return self._m_has_field_die_ignore_trigger_bullet self._m_has_field_die_ignore_trigger_bullet = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_die_ignore_trigger_bullet', None) @property def has_field_die_disappear_effect_delay(self): if hasattr(self, '_m_has_field_die_disappear_effect_delay'): return self._m_has_field_die_disappear_effect_delay self._m_has_field_die_disappear_effect_delay = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_die_disappear_effect_delay', None) @property def has_field_rag_doll_die_end_time_delay(self): if hasattr(self, '_m_has_field_rag_doll_die_end_time_delay'): return self._m_has_field_rag_doll_die_end_time_delay self._m_has_field_rag_doll_die_end_time_delay = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_rag_doll_die_end_time_delay', None) @property def has_field_ignore_element_die(self): if hasattr(self, '_m_has_field_ignore_element_die'): return self._m_has_field_ignore_element_die self._m_has_field_ignore_element_die = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_ignore_element_die', None) @property def has_field_mute_billboard(self): if hasattr(self, '_m_has_field_mute_billboard'): return self._m_has_field_mute_billboard self._m_has_field_mute_billboard = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_mute_billboard', None) @property def has_field_die_end_time(self): if hasattr(self, '_m_has_field_die_end_time'): return self._m_has_field_die_end_time self._m_has_field_die_end_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_die_end_time', None) @property def has_field_mute_hit_box(self): if hasattr(self, '_m_has_field_mute_hit_box'): return self._m_has_field_mute_hit_box self._m_has_field_mute_hit_box = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_mute_hit_box', None) @property def has_field_mute_all_shader_die_eff(self): if hasattr(self, '_m_has_field_mute_all_shader_die_eff'): return self._m_has_field_mute_all_shader_die_eff self._m_has_field_mute_all_shader_die_eff = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_mute_all_shader_die_eff', None) @property def has_field_fall_when_air_die(self): if hasattr(self, '_m_has_field_fall_when_air_die'): return self._m_has_field_fall_when_air_die self._m_has_field_fall_when_air_die = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_fall_when_air_die', None) @property def has_field_die_disappear_effect(self): if hasattr(self, '_m_has_field_die_disappear_effect'): return self._m_has_field_die_disappear_effect self._m_has_field_die_disappear_effect = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_die_disappear_effect', None) @property def has_field_mute_push_collider(self): if hasattr(self, '_m_has_field_mute_push_collider'): return self._m_has_field_mute_push_collider self._m_has_field_mute_push_collider = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_mute_push_collider', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_die_shader_data(self): if hasattr(self, '_m_has_field_die_shader_data'): return self._m_has_field_die_shader_data self._m_has_field_die_shader_data = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_die_shader_data', None) class EnumMonsterSizeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonsterSizeType, self.data.value) return getattr(self, '_m_value', None) class ActivitySummerTimeRacePreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_desc', None) class ByTargetElement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumMonitorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonitorType, self.data.value) return getattr(self, '_m_value', None) class TriggerSetRenderersEnable(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_render_names: self.render_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_render_names(self): if hasattr(self, '_m_has_field_render_names'): return self._m_has_field_render_names self._m_has_field_render_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_render_names', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class GroupLinksBundleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_link_type: self.link_type = Output.EnumActivityGroupLinkType(self._io, self, self._root) if self.has_field_group_list: self.group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_radius: self.hint_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_type: self.reward_type = Output.EnumActivityGroupLinkRewardType(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tips: self.tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumActivityGroupLinkPlayType(self._io, self, self._root) if self.has_field_auto_tracing_after_active: self.auto_tracing_after_active = self._io.read_u1() if self.has_field_ui_radius: self.ui_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_track_id: self.track_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guest_show: self.guest_show = self._io.read_u1() if self.has_field_is_default_show_mark: self.is_default_show_mark = self._io.read_u1() @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hint_group', None) @property def has_field_ui_radius(self): if hasattr(self, '_m_has_field_ui_radius'): return self._m_has_field_ui_radius self._m_has_field_ui_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_ui_radius', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_auto_tracing_after_active(self): if hasattr(self, '_m_has_field_auto_tracing_after_active'): return self._m_has_field_auto_tracing_after_active self._m_has_field_auto_tracing_after_active = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_auto_tracing_after_active', None) @property def has_field_tips(self): if hasattr(self, '_m_has_field_tips'): return self._m_has_field_tips self._m_has_field_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_tips', None) @property def has_field_group_list(self): if hasattr(self, '_m_has_field_group_list'): return self._m_has_field_group_list self._m_has_field_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_list', None) @property def has_field_link_type(self): if hasattr(self, '_m_has_field_link_type'): return self._m_has_field_link_type self._m_has_field_link_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_link_type', None) @property def has_field_hint_radius(self): if hasattr(self, '_m_has_field_hint_radius'): return self._m_has_field_hint_radius self._m_has_field_hint_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_hint_radius', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_track_id(self): if hasattr(self, '_m_has_field_track_id'): return self._m_has_field_track_id self._m_has_field_track_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_track_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_guest_show(self): if hasattr(self, '_m_has_field_guest_show'): return self._m_has_field_guest_show self._m_has_field_guest_show = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_guest_show', None) @property def has_field_is_default_show_mark(self): if hasattr(self, '_m_has_field_is_default_show_mark'): return self._m_has_field_is_default_show_mark self._m_has_field_is_default_show_mark = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_is_default_show_mark', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_revise_level', None) @property def has_field_reward_type(self): if hasattr(self, '_m_has_field_reward_type'): return self._m_has_field_reward_type self._m_has_field_reward_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_type', None) class ConfigAiOrderSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_master: self.master = Output.ConfigAiOrderMasterSetting(self._io, self, self._root) if self.has_field_servant: self.servant = Output.ConfigAiOrderServantSetting(self._io, self, self._root) if self.has_field_command_setting: self.command_setting = Output.ConfigAiCommandSetting(self._io, self, self._root) @property def has_field_master(self): if hasattr(self, '_m_has_field_master'): return self._m_has_field_master self._m_has_field_master = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_master', None) @property def has_field_servant(self): if hasattr(self, '_m_has_field_servant'): return self._m_has_field_servant self._m_has_field_servant = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_servant', None) @property def has_field_command_setting(self): if hasattr(self, '_m_has_field_command_setting'): return self._m_has_field_command_setting self._m_has_field_command_setting = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_command_setting', None) class EnumNewActivitySaleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NewActivitySaleType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideTabItemCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_path: self.path = AuxTypes.String(self._io, self, self._root) if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_page_type: self.page_type = Output.EnumGuidePageType(self._io, self, self._root) if self.has_field_is_select: self.is_select = self._io.read_u1() @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_context_name', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_page_type(self): if hasattr(self, '_m_has_field_page_type'): return self._m_has_field_page_type self._m_has_field_page_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_page_type', None) @property def has_field_path(self): if hasattr(self, '_m_has_field_path'): return self._m_has_field_path self._m_has_field_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_path', None) @property def has_field_is_select(self): if hasattr(self, '_m_has_field_is_select'): return self._m_has_field_is_select self._m_has_field_is_select = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_is_select', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class SelectActionPointById(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_point_id: self.action_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_action_point_id(self): if hasattr(self, '_m_has_field_action_point_id'): return self._m_has_field_action_point_id self._m_has_field_action_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_point_id', None) class AvatarHeroEntityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGearGadgetShaftExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_layer_offset_list: self.layer_offset_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_can_not_place_tip_offset: self.can_not_place_tip_offset = self._io.read_f4le() if self.has_field_clench_rate: self.clench_rate = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_layer_offset_list(self): if hasattr(self, '_m_has_field_layer_offset_list'): return self._m_has_field_layer_offset_list self._m_has_field_layer_offset_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_layer_offset_list', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_can_not_place_tip_offset(self): if hasattr(self, '_m_has_field_can_not_place_tip_offset'): return self._m_has_field_can_not_place_tip_offset self._m_has_field_can_not_place_tip_offset = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_can_not_place_tip_offset', None) @property def has_field_clench_rate(self): if hasattr(self, '_m_has_field_clench_rate'): return self._m_has_field_clench_rate self._m_has_field_clench_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_clench_rate', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_radius', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFleeData(self._io, self, self._root) class ConfigPerfNumberItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPerfItemOverrideInfoBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_value: self.override_value = self._io.read_f4le() @property def has_field_override_value(self): if hasattr(self, '_m_has_field_override_value'): return self._m_has_field_override_value self._m_has_field_override_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_value', None) @property def requirement_array(self): if hasattr(self, '_m_requirement_array'): return self._m_requirement_array self._m_requirement_array = self.base.requirement_array return getattr(self, '_m_requirement_array', None) @property def device_override_rule(self): if hasattr(self, '_m_device_override_rule'): return self._m_device_override_rule self._m_device_override_rule = self.base.device_override_rule return getattr(self, '_m_device_override_rule', None) @property def combine_override_rule(self): if hasattr(self, '_m_combine_override_rule'): return self._m_combine_override_rule self._m_combine_override_rule = self.base.combine_override_rule return getattr(self, '_m_combine_override_rule', None) class DispConfigAiTacticBaseSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigAiCombatFixedMoveSetting(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigAiFacingMoveSetting(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigAiFleeOnBlockAvatarLandingSetting(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigAiFollowServerRouteSetting(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigAiLandingSetting(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigAiReactActionPointSetting(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigAiSpacialAdjustSetting(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigAiPatrolFollowSetting(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigAiReturnToBornPosSetting(self._io, self, self._root) elif _on == 27: self.data = Output.ConfigAiFishingBitesBaitSetting(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigAiFindBackSetting(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigAiSurroundSetting(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigAiGroupSurroundSetting(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigAiFollowScriptedPathSetting(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigAiInvestigateSetting(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigAiSpacialProbeSetting(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigAiScriptedMoveToSetting(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigAiCrabMoveSetting(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigAiCombatFollowMoveSetting(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigAiMeleeChargeSetting(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigAiSpacialWanderSetting(self._io, self, self._root) elif _on == 28: self.data = Output.ConfigAiFishingPretendBitesSetting(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigAiFleeSetting(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigAiSpacialChaseSetting(self._io, self, self._root) elif _on == 26: self.data = Output.ConfigAiBrownianMotionSetting(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigAiWanderSetting(self._io, self, self._root) elif _on == 29: self.data = Output.ConfigAiFishingFleeSetting(self._io, self, self._root) elif _on == 25: self.data = Output.ConfigAiExtractionSetting(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigAiBirdCirclingSetting(self._io, self, self._root) elif _on == 30: self.data = Output.ConfigAiSpacialFacingMoveSetting(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class CostStaminaMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cost_stamina_delta: self.cost_stamina_delta = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cost_stamina_ratio: self.cost_stamina_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_on_stamina_empty: self.on_stamina_empty = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_cost_stamina_delta(self): if hasattr(self, '_m_has_field_cost_stamina_delta'): return self._m_has_field_cost_stamina_delta self._m_has_field_cost_stamina_delta = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cost_stamina_delta', None) @property def has_field_cost_stamina_ratio(self): if hasattr(self, '_m_has_field_cost_stamina_ratio'): return self._m_has_field_cost_stamina_ratio self._m_has_field_cost_stamina_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cost_stamina_ratio', None) @property def has_field_on_stamina_empty(self): if hasattr(self, '_m_has_field_on_stamina_empty'): return self._m_has_field_on_stamina_empty self._m_has_field_on_stamina_empty = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_stamina_empty', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConstValueExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_name: self.name = Output.EnumConstValueType(self._io, self, self._root) if self.has_field_value: self.value = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_value', None) class ChangePropTypeValueMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_prop_type: self.prop_type = AuxTypes.String(self._io, self, self._root) if self.has_field_energy_cost_delta: self.energy_cost_delta = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_prop_type(self): if hasattr(self, '_m_has_field_prop_type'): return self._m_has_field_prop_type self._m_has_field_prop_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_prop_type', None) @property def has_field_energy_cost_delta(self): if hasattr(self, '_m_has_field_energy_cost_delta'): return self._m_has_field_energy_cost_delta self._m_has_field_energy_cost_delta = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_energy_cost_delta', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class CustomGadgetNodeSlotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLcGadgetIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLcBaseIntee(self._io, self, self._root) @property def trigger_shape_free_interaction_height(self): if hasattr(self, '_m_trigger_shape_free_interaction_height'): return self._m_trigger_shape_free_interaction_height self._m_trigger_shape_free_interaction_height = self.base.trigger_shape_free_interaction_height return getattr(self, '_m_trigger_shape_free_interaction_height', None) @property def trigger_shape_out(self): if hasattr(self, '_m_trigger_shape_out'): return self._m_trigger_shape_out self._m_trigger_shape_out = self.base.trigger_shape_out return getattr(self, '_m_trigger_shape_out', None) @property def trigger_shape_in_offset(self): if hasattr(self, '_m_trigger_shape_in_offset'): return self._m_trigger_shape_in_offset self._m_trigger_shape_in_offset = self.base.trigger_shape_in_offset return getattr(self, '_m_trigger_shape_in_offset', None) @property def trigger_shape_in_height(self): if hasattr(self, '_m_trigger_shape_in_height'): return self._m_trigger_shape_in_height self._m_trigger_shape_in_height = self.base.trigger_shape_in_height return getattr(self, '_m_trigger_shape_in_height', None) @property def trigger_shape_in(self): if hasattr(self, '_m_trigger_shape_in'): return self._m_trigger_shape_in self._m_trigger_shape_in = self.base.trigger_shape_in return getattr(self, '_m_trigger_shape_in', None) @property def trigger_shape_free_interaction_offset(self): if hasattr(self, '_m_trigger_shape_free_interaction_offset'): return self._m_trigger_shape_free_interaction_offset self._m_trigger_shape_free_interaction_offset = self.base.trigger_shape_free_interaction_offset return getattr(self, '_m_trigger_shape_free_interaction_offset', None) @property def trigger_shape_out_offset(self): if hasattr(self, '_m_trigger_shape_out_offset'): return self._m_trigger_shape_out_offset self._m_trigger_shape_out_offset = self.base.trigger_shape_out_offset return getattr(self, '_m_trigger_shape_out_offset', None) @property def trigger_shape_out_height(self): if hasattr(self, '_m_trigger_shape_out_height'): return self._m_trigger_shape_out_height self._m_trigger_shape_out_height = self.base.trigger_shape_out_height return getattr(self, '_m_trigger_shape_out_height', None) @property def trigger_shape_free_interaction(self): if hasattr(self, '_m_trigger_shape_free_interaction'): return self._m_trigger_shape_free_interaction self._m_trigger_shape_free_interaction = self.base.trigger_shape_free_interaction return getattr(self, '_m_trigger_shape_free_interaction', None) class GroupRecordTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMarkLayerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkLayerType, self.data.value) return getattr(self, '_m_value', None) class ConfigSchedulePlatformComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAiSkillCdAvailableNow(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_i_ds: self.skill_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_skill_i_ds(self): if hasattr(self, '_m_has_field_skill_i_ds'): return self._m_has_field_skill_i_ds self._m_has_field_skill_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_i_ds', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfEnumInputActionGroupTypeArrayOfEnumInputActionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumInputActionGroupTypeArrayOfEnumInputActionTypeLengthU(self._io, self, self._root)) class ArrayOfPointInfoLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.PointInfo(self._io, self, self._root)) class ConfigCustomNodeTreeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_node_list: self.node_list = Output.ArrayOfConfigCustomNodeInfoLengthU(self._io, self, self._root) @property def has_field_node_list(self): if hasattr(self, '_m_has_field_node_list'): return self._m_has_field_node_list self._m_has_field_node_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_node_list', None) class EnumMpPlayerSettleSyncType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MpPlayerSettleSyncType, self.data.value) return getattr(self, '_m_value', None) class ArithTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClearEndura(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_percent: self.percent = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_percent(self): if hasattr(self, '_m_has_field_percent'): return self._m_has_field_percent self._m_has_field_percent = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_percent', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class UnitDurationMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_trigger: self.is_trigger = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_steps: self.steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) @property def has_field_is_trigger(self): if hasattr(self, '_m_has_field_is_trigger'): return self._m_has_field_is_trigger self._m_has_field_is_trigger = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_trigger', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_steps(self): if hasattr(self, '_m_has_field_steps'): return self._m_has_field_steps self._m_has_field_steps = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_steps', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfFireworksReformParamConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FireworksReformParamConfig(self._io, self, self._root)) class EnumPersistentFurnitureType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PersistentFurnitureType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigJudgeEntityInViewDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigJudgeEntityInViewData(self._io, self, self._root)) class DungeonFogEffects(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_camera_fog_effect_name: self.camera_fog_effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_player_fog_effect_name: self.player_fog_effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_local_offset: self.local_offset = Output.Vector(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_camera_fog_effect_name(self): if hasattr(self, '_m_has_field_camera_fog_effect_name'): return self._m_has_field_camera_fog_effect_name self._m_has_field_camera_fog_effect_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camera_fog_effect_name', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_local_offset(self): if hasattr(self, '_m_has_field_local_offset'): return self._m_has_field_local_offset self._m_has_field_local_offset = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_local_offset', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_player_fog_effect_name(self): if hasattr(self, '_m_has_field_player_fog_effect_name'): return self._m_has_field_player_fog_effect_name self._m_has_field_player_fog_effect_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_player_fog_effect_name', None) class IrodoriQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfSettingSet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_number_items: self.number_items = Output.DictOfAuxTypesStringConfigPerfNumberItem(self._io, self, self._root) if self.has_field_number_array_items: self.number_array_items = Output.DictOfAuxTypesStringConfigPerfNumberArrayItem(self._io, self, self._root) if self.has_field_string_key_items: self.string_key_items = Output.DictOfAuxTypesStringConfigPerfStringKeyItem(self._io, self, self._root) if self.has_field_grade_items: self.grade_items = Output.DictOfAuxTypesStringConfigPerfGradeItem(self._io, self, self._root) if self.has_field_bool_items: self.bool_items = Output.DictOfAuxTypesStringConfigPerfBoolItem(self._io, self, self._root) if self.has_field_combined_items: self.combined_items = Output.DictOfAuxTypesStringConfigPerfCombinedItem(self._io, self, self._root) @property def has_field_string_key_items(self): if hasattr(self, '_m_has_field_string_key_items'): return self._m_has_field_string_key_items self._m_has_field_string_key_items = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_string_key_items', None) @property def has_field_combined_items(self): if hasattr(self, '_m_has_field_combined_items'): return self._m_has_field_combined_items self._m_has_field_combined_items = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_combined_items', None) @property def has_field_number_array_items(self): if hasattr(self, '_m_has_field_number_array_items'): return self._m_has_field_number_array_items self._m_has_field_number_array_items = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number_array_items', None) @property def has_field_grade_items(self): if hasattr(self, '_m_has_field_grade_items'): return self._m_has_field_grade_items self._m_has_field_grade_items = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_grade_items', None) @property def has_field_bool_items(self): if hasattr(self, '_m_has_field_bool_items'): return self._m_has_field_bool_items self._m_has_field_bool_items = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_bool_items', None) @property def has_field_number_items(self): if hasattr(self, '_m_has_field_number_items'): return self._m_has_field_number_items self._m_has_field_number_items = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number_items', None) class PushInterActionByConfigPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cfg_path: self.cfg_path = AuxTypes.String(self._io, self, self._root) if self.has_field_is_external: self.is_external = self._io.read_u1() @property def has_field_cfg_path(self): if hasattr(self, '_m_has_field_cfg_path'): return self._m_has_field_cfg_path self._m_has_field_cfg_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cfg_path', None) @property def has_field_is_external(self): if hasattr(self, '_m_has_field_is_external'): return self._m_has_field_is_external self._m_has_field_is_external = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_external', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigHomeworldFurnitureSet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() if self.has_field_furniture_units: self.furniture_units = Output.ArrayOfConfigHomeworldFurnitureUnitLengthU(self._io, self, self._root) if self.has_field_npc_spawn_points: self.npc_spawn_points = Output.ArrayOfConfigHomeworldSuiteNpcSpawnPointLengthU(self._io, self, self._root) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_furniture_units(self): if hasattr(self, '_m_has_field_furniture_units'): return self._m_has_field_furniture_units self._m_has_field_furniture_units = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_furniture_units', None) @property def has_field_npc_spawn_points(self): if hasattr(self, '_m_has_field_npc_spawn_points'): return self._m_has_field_npc_spawn_points self._m_has_field_npc_spawn_points = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_npc_spawn_points', None) class MusicInstrumentConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_instrument_id: self.instrument_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_widget_id: self.widget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perform_id: self.perform_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_free_mode_perfab_path: self.free_mode_perfab_path = AuxTypes.String(self._io, self, self._root) @property def has_field_instrument_id(self): if hasattr(self, '_m_has_field_instrument_id'): return self._m_has_field_instrument_id self._m_has_field_instrument_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_instrument_id', None) @property def has_field_widget_id(self): if hasattr(self, '_m_has_field_widget_id'): return self._m_has_field_widget_id self._m_has_field_widget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_widget_id', None) @property def has_field_perform_id(self): if hasattr(self, '_m_has_field_perform_id'): return self._m_has_field_perform_id self._m_has_field_perform_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_perform_id', None) @property def has_field_free_mode_perfab_path(self): if hasattr(self, '_m_has_field_free_mode_perfab_path'): return self._m_has_field_free_mode_perfab_path self._m_has_field_free_mode_perfab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_free_mode_perfab_path', None) class LifeStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiFollowServerRouteData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFollowServerRouteData(self._io, self, self._root) class AvatarReplaceCostumeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRecipeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RecipeType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumCombatPropertyIndexLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumCombatPropertyIndex(self._io, self, self._root)) class MixinCopyParentModifiersOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WorldAreaLevelupActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabLoopDungeonRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_grade: self.score_grade = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_score_grade(self): if hasattr(self, '_m_has_field_score_grade'): return self._m_has_field_score_grade self._m_has_field_score_grade = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_score_grade', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) class EnumGalleryProgressScoreType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GalleryProgressScoreType, self.data.value) return getattr(self, '_m_value', None) class ActivityBannerUiElementTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EquipInSlotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHuntingMonsterGroupType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingMonsterGroupType, self.data.value) return getattr(self, '_m_value', None) class ChannellerSlabConditionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFishSkillCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FishSkillCategory, self.data.value) return getattr(self, '_m_value', None) class ArrayOfQuestContentLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestContent(self._io, self, self._root)) class LunaRiteSearchingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigInterGrpIdLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigInterGrpId(self._io, self, self._root)) class MichiaeBossChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerformanceSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_prop_cache_count: self.scene_prop_cache_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_bundle_unload_lru_retire_time: self.bundle_unload_lru_retire_time = self._io.read_f4le() if self.has_field_bundle_unload_lru_retire_size: self.bundle_unload_lru_retire_size = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_bundle_unload_lru_capcity: self.bundle_unload_lru_capcity = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_game_object_pool_count: self.game_object_pool_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_final_ik: self.use_final_ik = self._io.read_u1() if self.has_field_enable_audio_surface_multiprobing: self.enable_audio_surface_multiprobing = self._io.read_u1() if self.has_field_enable_audio_focus_attenuation: self.enable_audio_focus_attenuation = self._io.read_u1() if self.has_field_enable_audio_occlusion_racasts: self.enable_audio_occlusion_racasts = self._io.read_u1() if self.has_field_enable_audio_listener_outreach_detetion: self.enable_audio_listener_outreach_detetion = self._io.read_u1() if self.has_field_cached_entity_time: self.cached_entity_time = self._io.read_f4le() if self.has_field_cached_entity_dist: self.cached_entity_dist = self._io.read_f4le() if self.has_field_use_head_control: self.use_head_control = self._io.read_u1() if self.has_field_use_avatar_grass_displacement: self.use_avatar_grass_displacement = self._io.read_u1() if self.has_field_use_other_enttiy_grass_displacement: self.use_other_enttiy_grass_displacement = self._io.read_u1() if self.has_field_use_wind_zone_grass_displacement: self.use_wind_zone_grass_displacement = self._io.read_u1() if self.has_field_use_ragdoll: self.use_ragdoll = self._io.read_u1() if self.has_field_use_fbik: self.use_fbik = self._io.read_u1() if self.has_field_wind_flag_max_quality_level: self.wind_flag_max_quality_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_dynamic_bone: self.use_dynamic_bone = self._io.read_u1() if self.has_field_climb_ik_quality_level: self.climb_ik_quality_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_climb_ik: self.use_climb_ik = self._io.read_u1() if self.has_field_use_move_ik: self.use_move_ik = self._io.read_u1() if self.has_field_use_effect_lod: self.use_effect_lod = self._io.read_u1() if self.has_field_ragdoll_limit_count: self.ragdoll_limit_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ragdoll_pool_size: self.ragdoll_pool_size = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ragdoll_pool_same_id_size: self.ragdoll_pool_same_id_size = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_climb_ik_quality_level(self): if hasattr(self, '_m_has_field_climb_ik_quality_level'): return self._m_has_field_climb_ik_quality_level self._m_has_field_climb_ik_quality_level = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_climb_ik_quality_level', None) @property def has_field_ragdoll_pool_same_id_size(self): if hasattr(self, '_m_has_field_ragdoll_pool_same_id_size'): return self._m_has_field_ragdoll_pool_same_id_size self._m_has_field_ragdoll_pool_same_id_size = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_ragdoll_pool_same_id_size', None) @property def has_field_use_climb_ik(self): if hasattr(self, '_m_has_field_use_climb_ik'): return self._m_has_field_use_climb_ik self._m_has_field_use_climb_ik = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_use_climb_ik', None) @property def has_field_use_other_enttiy_grass_displacement(self): if hasattr(self, '_m_has_field_use_other_enttiy_grass_displacement'): return self._m_has_field_use_other_enttiy_grass_displacement self._m_has_field_use_other_enttiy_grass_displacement = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_use_other_enttiy_grass_displacement', None) @property def has_field_use_fbik(self): if hasattr(self, '_m_has_field_use_fbik'): return self._m_has_field_use_fbik self._m_has_field_use_fbik = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_use_fbik', None) @property def has_field_wind_flag_max_quality_level(self): if hasattr(self, '_m_has_field_wind_flag_max_quality_level'): return self._m_has_field_wind_flag_max_quality_level self._m_has_field_wind_flag_max_quality_level = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_wind_flag_max_quality_level', None) @property def has_field_use_final_ik(self): if hasattr(self, '_m_has_field_use_final_ik'): return self._m_has_field_use_final_ik self._m_has_field_use_final_ik = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_use_final_ik', None) @property def has_field_bundle_unload_lru_capcity(self): if hasattr(self, '_m_has_field_bundle_unload_lru_capcity'): return self._m_has_field_bundle_unload_lru_capcity self._m_has_field_bundle_unload_lru_capcity = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_bundle_unload_lru_capcity', None) @property def has_field_bundle_unload_lru_retire_time(self): if hasattr(self, '_m_has_field_bundle_unload_lru_retire_time'): return self._m_has_field_bundle_unload_lru_retire_time self._m_has_field_bundle_unload_lru_retire_time = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_bundle_unload_lru_retire_time', None) @property def has_field_cached_entity_time(self): if hasattr(self, '_m_has_field_cached_entity_time'): return self._m_has_field_cached_entity_time self._m_has_field_cached_entity_time = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_cached_entity_time', None) @property def has_field_enable_audio_focus_attenuation(self): if hasattr(self, '_m_has_field_enable_audio_focus_attenuation'): return self._m_has_field_enable_audio_focus_attenuation self._m_has_field_enable_audio_focus_attenuation = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enable_audio_focus_attenuation', None) @property def has_field_enable_audio_occlusion_racasts(self): if hasattr(self, '_m_has_field_enable_audio_occlusion_racasts'): return self._m_has_field_enable_audio_occlusion_racasts self._m_has_field_enable_audio_occlusion_racasts = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enable_audio_occlusion_racasts', None) @property def has_field_use_ragdoll(self): if hasattr(self, '_m_has_field_use_ragdoll'): return self._m_has_field_use_ragdoll self._m_has_field_use_ragdoll = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_use_ragdoll', None) @property def has_field_use_avatar_grass_displacement(self): if hasattr(self, '_m_has_field_use_avatar_grass_displacement'): return self._m_has_field_use_avatar_grass_displacement self._m_has_field_use_avatar_grass_displacement = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_use_avatar_grass_displacement', None) @property def has_field_scene_prop_cache_count(self): if hasattr(self, '_m_has_field_scene_prop_cache_count'): return self._m_has_field_scene_prop_cache_count self._m_has_field_scene_prop_cache_count = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_scene_prop_cache_count', None) @property def has_field_use_head_control(self): if hasattr(self, '_m_has_field_use_head_control'): return self._m_has_field_use_head_control self._m_has_field_use_head_control = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_use_head_control', None) @property def has_field_ragdoll_limit_count(self): if hasattr(self, '_m_has_field_ragdoll_limit_count'): return self._m_has_field_ragdoll_limit_count self._m_has_field_ragdoll_limit_count = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_ragdoll_limit_count', None) @property def has_field_use_wind_zone_grass_displacement(self): if hasattr(self, '_m_has_field_use_wind_zone_grass_displacement'): return self._m_has_field_use_wind_zone_grass_displacement self._m_has_field_use_wind_zone_grass_displacement = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_use_wind_zone_grass_displacement', None) @property def has_field_cached_entity_dist(self): if hasattr(self, '_m_has_field_cached_entity_dist'): return self._m_has_field_cached_entity_dist self._m_has_field_cached_entity_dist = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_cached_entity_dist', None) @property def has_field_use_effect_lod(self): if hasattr(self, '_m_has_field_use_effect_lod'): return self._m_has_field_use_effect_lod self._m_has_field_use_effect_lod = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_use_effect_lod', None) @property def has_field_enable_audio_listener_outreach_detetion(self): if hasattr(self, '_m_has_field_enable_audio_listener_outreach_detetion'): return self._m_has_field_enable_audio_listener_outreach_detetion self._m_has_field_enable_audio_listener_outreach_detetion = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_enable_audio_listener_outreach_detetion', None) @property def has_field_bundle_unload_lru_retire_size(self): if hasattr(self, '_m_has_field_bundle_unload_lru_retire_size'): return self._m_has_field_bundle_unload_lru_retire_size self._m_has_field_bundle_unload_lru_retire_size = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_bundle_unload_lru_retire_size', None) @property def has_field_ragdoll_pool_size(self): if hasattr(self, '_m_has_field_ragdoll_pool_size'): return self._m_has_field_ragdoll_pool_size self._m_has_field_ragdoll_pool_size = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_ragdoll_pool_size', None) @property def has_field_use_dynamic_bone(self): if hasattr(self, '_m_has_field_use_dynamic_bone'): return self._m_has_field_use_dynamic_bone self._m_has_field_use_dynamic_bone = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_use_dynamic_bone', None) @property def has_field_game_object_pool_count(self): if hasattr(self, '_m_has_field_game_object_pool_count'): return self._m_has_field_game_object_pool_count self._m_has_field_game_object_pool_count = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_game_object_pool_count', None) @property def has_field_use_move_ik(self): if hasattr(self, '_m_has_field_use_move_ik'): return self._m_has_field_use_move_ik self._m_has_field_use_move_ik = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_use_move_ik', None) @property def has_field_enable_audio_surface_multiprobing(self): if hasattr(self, '_m_has_field_enable_audio_surface_multiprobing'): return self._m_has_field_enable_audio_surface_multiprobing self._m_has_field_enable_audio_surface_multiprobing = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_enable_audio_surface_multiprobing', None) class SceneMpTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RaycastTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSettleShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SettleShowType, self.data.value) return getattr(self, '_m_value', None) class Repeated(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_repeat_times: self.repeat_times = AuxTypes.DynamicInt(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_repeat_times(self): if hasattr(self, '_m_has_field_repeat_times'): return self._m_has_field_repeat_times self._m_has_field_repeat_times = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_repeat_times', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class HandbookQuestGuideExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_guide_id: self.guide_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_id: self.type_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_label: self.label = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_type: self.quest_type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_is_hiden_wq: self.is_hiden_wq = self._io.read_u1() if self.has_field_hiden_sub_quest_id: self.hiden_sub_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_point_id: self.mark_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_guide_id: self.special_guide_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_label_tip: self.show_label_tip = self._io.read_u1() if self.has_field_show_conds: self.show_conds = Output.ArrayOfHandbookQuestGuideShowCondLengthS(self._io, self, self._root) @property def has_field_label(self): if hasattr(self, '_m_has_field_label'): return self._m_has_field_label self._m_has_field_label = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_label', None) @property def has_field_type_id(self): if hasattr(self, '_m_has_field_type_id'): return self._m_has_field_type_id self._m_has_field_type_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type_id', None) @property def has_field_show_conds(self): if hasattr(self, '_m_has_field_show_conds'): return self._m_has_field_show_conds self._m_has_field_show_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_show_conds', None) @property def has_field_special_guide_id(self): if hasattr(self, '_m_has_field_special_guide_id'): return self._m_has_field_special_guide_id self._m_has_field_special_guide_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_special_guide_id', None) @property def has_field_hiden_sub_quest_id(self): if hasattr(self, '_m_has_field_hiden_sub_quest_id'): return self._m_has_field_hiden_sub_quest_id self._m_has_field_hiden_sub_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_hiden_sub_quest_id', None) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_show_label_tip(self): if hasattr(self, '_m_has_field_show_label_tip'): return self._m_has_field_show_label_tip self._m_has_field_show_label_tip = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_show_label_tip', None) @property def has_field_quest_type(self): if hasattr(self, '_m_has_field_quest_type'): return self._m_has_field_quest_type self._m_has_field_quest_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_type', None) @property def has_field_is_hiden_wq(self): if hasattr(self, '_m_has_field_is_hiden_wq'): return self._m_has_field_is_hiden_wq self._m_has_field_is_hiden_wq = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_hiden_wq', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_mark_point_id(self): if hasattr(self, '_m_has_field_mark_point_id'): return self._m_has_field_mark_point_id self._m_has_field_mark_point_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_mark_point_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_order', None) @property def has_field_guide_id(self): if hasattr(self, '_m_has_field_guide_id'): return self._m_has_field_guide_id self._m_has_field_guide_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_guide_id', None) class EnumQteStepActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepActionType, self.data.value) return getattr(self, '_m_value', None) class EnumEmoRecordTypeEnum(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EmoRecordTypeEnum, self.data.value) return getattr(self, '_m_value', None) class GetHpHealedToGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumGlobalValueChangeType(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigPointArray(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_point_array_id: self.point_array_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_platform_point_list: self.platform_point_list = Output.ArrayOfConfigPointLengthU(self._io, self, self._root) @property def has_field_point_array_id(self): if hasattr(self, '_m_has_field_point_array_id'): return self._m_has_field_point_array_id self._m_has_field_point_array_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_array_id', None) @property def has_field_platform_point_list(self): if hasattr(self, '_m_has_field_platform_point_list'): return self._m_has_field_platform_point_list self._m_has_field_platform_point_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_platform_point_list', None) class KvpOfDictAuxTypesStringConfigActionTokenChannelGroupInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigActionTokenChannelGroupInfo(self._io, self, self._root) class EmbeddedTextMapConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ServerLuaCall(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_lua_call_type: self.lua_call_type = Output.EnumLuaCallType(self._io, self, self._root) if self.has_field_is_target: self.is_target = self._io.read_u1() if self.has_field_call_param_list: self.call_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_func_name: self.func_name = AuxTypes.String(self._io, self, self._root) if self.has_field_param_num: self.param_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_call_param_list(self): if hasattr(self, '_m_has_field_call_param_list'): return self._m_has_field_call_param_list self._m_has_field_call_param_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_call_param_list', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_param3', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_target(self): if hasattr(self, '_m_has_field_is_target'): return self._m_has_field_is_target self._m_has_field_is_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_target', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_param2', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_func_name(self): if hasattr(self, '_m_has_field_func_name'): return self._m_has_field_func_name self._m_has_field_func_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_func_name', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_param1', None) @property def has_field_lua_call_type(self): if hasattr(self, '_m_has_field_lua_call_type'): return self._m_has_field_lua_call_type self._m_has_field_lua_call_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lua_call_type', None) @property def has_field_param_num(self): if hasattr(self, '_m_has_field_param_num'): return self._m_has_field_param_num self._m_has_field_param_num = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_param_num', None) class SelectTargetsByLcTriggerAll(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SelectTargets(self._io, self, self._root) @property def top_limit(self): if hasattr(self, '_m_top_limit'): return self._m_top_limit self._m_top_limit = self.base.top_limit return getattr(self, '_m_top_limit', None) @property def entity_type_priority(self): if hasattr(self, '_m_entity_type_priority'): return self._m_entity_type_priority self._m_entity_type_priority = self.base.entity_type_priority return getattr(self, '_m_entity_type_priority', None) @property def sort_type(self): if hasattr(self, '_m_sort_type'): return self._m_sort_type self._m_sort_type = self.base.sort_type return getattr(self, '_m_sort_type', None) class SetAnimatorInt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_int_id: self.int_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_persistent: self.persistent = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_persistent(self): if hasattr(self, '_m_has_field_persistent'): return self._m_has_field_persistent self._m_has_field_persistent = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_persistent', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def has_field_int_id(self): if hasattr(self, '_m_has_field_int_id'): return self._m_has_field_int_id self._m_has_field_int_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_int_id', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigDirectionByReflection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class BlitzRushParkourExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_open_day', None) class KillSelf(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_die_state_flage: self.die_state_flage = Output.EnumDieStateFlag(self._io, self, self._root) if self.has_field_ban_drop: self.ban_drop = self._io.read_u1() if self.has_field_ban_exp: self.ban_exp = self._io.read_u1() if self.has_field_ban_hp_percentage_drop: self.ban_hp_percentage_drop = self._io.read_u1() if self.has_field_kill_self_type: self.kill_self_type = Output.EnumKillSelfType(self._io, self, self._root) if self.has_field_hide_entity: self.hide_entity = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_ban_drop(self): if hasattr(self, '_m_has_field_ban_drop'): return self._m_has_field_ban_drop self._m_has_field_ban_drop = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ban_drop', None) @property def has_field_hide_entity(self): if hasattr(self, '_m_has_field_hide_entity'): return self._m_has_field_hide_entity self._m_has_field_hide_entity = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_hide_entity', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_die_state_flage(self): if hasattr(self, '_m_has_field_die_state_flage'): return self._m_has_field_die_state_flage self._m_has_field_die_state_flage = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_die_state_flage', None) @property def has_field_kill_self_type(self): if hasattr(self, '_m_has_field_kill_self_type'): return self._m_has_field_kill_self_type self._m_has_field_kill_self_type = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_kill_self_type', None) @property def has_field_ban_exp(self): if hasattr(self, '_m_has_field_ban_exp'): return self._m_has_field_ban_exp self._m_has_field_ban_exp = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ban_exp', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_ban_hp_percentage_drop(self): if hasattr(self, '_m_has_field_ban_hp_percentage_drop'): return self._m_has_field_ban_hp_percentage_drop self._m_has_field_ban_hp_percentage_drop = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ban_hp_percentage_drop', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class BartenderBasicExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prequest_id: self.prequest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_reward_watcher: self.furniture_reward_watcher = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_reward_id: self.furniture_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_namecard_reward_watcher: self.namecard_reward_watcher = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_namecard_reward_id: self.namecard_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_material_count: self.min_material_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_material_count: self.max_material_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_mark_id: self.npc_mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_open_day: self.challenge_open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_open_cond_id: self.challenge_open_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_open_cond_id: self.story_open_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_ending_quest_id: self.main_ending_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_challenge_open_day(self): if hasattr(self, '_m_has_field_challenge_open_day'): return self._m_has_field_challenge_open_day self._m_has_field_challenge_open_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_challenge_open_day', None) @property def has_field_furniture_reward_id(self): if hasattr(self, '_m_has_field_furniture_reward_id'): return self._m_has_field_furniture_reward_id self._m_has_field_furniture_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_furniture_reward_id', None) @property def has_field_namecard_reward_id(self): if hasattr(self, '_m_has_field_namecard_reward_id'): return self._m_has_field_namecard_reward_id self._m_has_field_namecard_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_namecard_reward_id', None) @property def has_field_min_material_count(self): if hasattr(self, '_m_has_field_min_material_count'): return self._m_has_field_min_material_count self._m_has_field_min_material_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_min_material_count', None) @property def has_field_npc_mark_id(self): if hasattr(self, '_m_has_field_npc_mark_id'): return self._m_has_field_npc_mark_id self._m_has_field_npc_mark_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_npc_mark_id', None) @property def has_field_challenge_open_cond_id(self): if hasattr(self, '_m_has_field_challenge_open_cond_id'): return self._m_has_field_challenge_open_cond_id self._m_has_field_challenge_open_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_challenge_open_cond_id', None) @property def has_field_furniture_reward_watcher(self): if hasattr(self, '_m_has_field_furniture_reward_watcher'): return self._m_has_field_furniture_reward_watcher self._m_has_field_furniture_reward_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_furniture_reward_watcher', None) @property def has_field_max_material_count(self): if hasattr(self, '_m_has_field_max_material_count'): return self._m_has_field_max_material_count self._m_has_field_max_material_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_max_material_count', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_main_ending_quest_id(self): if hasattr(self, '_m_has_field_main_ending_quest_id'): return self._m_has_field_main_ending_quest_id self._m_has_field_main_ending_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_main_ending_quest_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_namecard_reward_watcher(self): if hasattr(self, '_m_has_field_namecard_reward_watcher'): return self._m_has_field_namecard_reward_watcher self._m_has_field_namecard_reward_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_namecard_reward_watcher', None) @property def has_field_story_open_cond_id(self): if hasattr(self, '_m_has_field_story_open_cond_id'): return self._m_has_field_story_open_cond_id self._m_has_field_story_open_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_story_open_cond_id', None) @property def has_field_prequest_id(self): if hasattr(self, '_m_has_field_prequest_id'): return self._m_has_field_prequest_id self._m_has_field_prequest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_prequest_id', None) class FishPoolExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stock_list: self.stock_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_stock_guarantee: self.stock_guarantee = Output.DictOfAuxTypesVlqBase128LeUAuxTypesVlqBase128LeU(self._io, self, self._root) if self.has_field_stock_limit_list: self.stock_limit_list = Output.ArrayOfFishStockLimitLengthS(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_name: self.pool_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_desc: self.pool_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group: self.ability_group = AuxTypes.String(self._io, self, self._root) if self.has_field_team_ability_group: self.team_ability_group = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_id_list: self.drop_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_daily_limit_num: self.daily_limit_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exclude_fish: self.exclude_fish = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_ability_group(self): if hasattr(self, '_m_has_field_ability_group'): return self._m_has_field_ability_group self._m_has_field_ability_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_ability_group', None) @property def has_field_stock_guarantee(self): if hasattr(self, '_m_has_field_stock_guarantee'): return self._m_has_field_stock_guarantee self._m_has_field_stock_guarantee = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stock_guarantee', None) @property def has_field_pool_name(self): if hasattr(self, '_m_has_field_pool_name'): return self._m_has_field_pool_name self._m_has_field_pool_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pool_name', None) @property def has_field_stock_list(self): if hasattr(self, '_m_has_field_stock_list'): return self._m_has_field_stock_list self._m_has_field_stock_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stock_list', None) @property def has_field_stock_limit_list(self): if hasattr(self, '_m_has_field_stock_limit_list'): return self._m_has_field_stock_limit_list self._m_has_field_stock_limit_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stock_limit_list', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_num', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_drop_id_list(self): if hasattr(self, '_m_has_field_drop_id_list'): return self._m_has_field_drop_id_list self._m_has_field_drop_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_drop_id_list', None) @property def has_field_daily_limit_num(self): if hasattr(self, '_m_has_field_daily_limit_num'): return self._m_has_field_daily_limit_num self._m_has_field_daily_limit_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_daily_limit_num', None) @property def has_field_pool_desc(self): if hasattr(self, '_m_has_field_pool_desc'): return self._m_has_field_pool_desc self._m_has_field_pool_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_pool_desc', None) @property def has_field_team_ability_group(self): if hasattr(self, '_m_has_field_team_ability_group'): return self._m_has_field_team_ability_group self._m_has_field_team_ability_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_team_ability_group', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_exclude_fish(self): if hasattr(self, '_m_has_field_exclude_fish'): return self._m_has_field_exclude_fish self._m_has_field_exclude_fish = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_exclude_fish', None) class KvpOfDictEnumElementTypeDispConfigAbilityAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumElementType(self._io, self, self._root) self.value = Output.DispConfigAbilityAction(self._io, self, self._root) class SignInPeriodExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfab_path: self.perfab_path = AuxTypes.String(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_perfab_path(self): if hasattr(self, '_m_has_field_perfab_path'): return self._m_has_field_perfab_path self._m_has_field_perfab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_perfab_path', None) class ReliquaryCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideCenterVirtualDialActionCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_paimon_entry_type: self.paimon_entry_type = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_paimon_entry_type(self): if hasattr(self, '_m_has_field_paimon_entry_type'): return self._m_has_field_paimon_entry_type self._m_has_field_paimon_entry_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_paimon_entry_type', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class MarkPluginIconTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfOfferingActionContentLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.OfferingActionContent(self._io, self, self._root)) class ConfigAvatarHitBucketSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_melee_bucket_count: self.melee_bucket_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_melee_bucket_cd: self.melee_bucket_cd = self._io.read_f4le() if self.has_field_ranged_bucket_count: self.ranged_bucket_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ranged_bucket_cd: self.ranged_bucket_cd = self._io.read_f4le() @property def has_field_melee_bucket_count(self): if hasattr(self, '_m_has_field_melee_bucket_count'): return self._m_has_field_melee_bucket_count self._m_has_field_melee_bucket_count = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_melee_bucket_count', None) @property def has_field_melee_bucket_cd(self): if hasattr(self, '_m_has_field_melee_bucket_cd'): return self._m_has_field_melee_bucket_cd self._m_has_field_melee_bucket_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_melee_bucket_cd', None) @property def has_field_ranged_bucket_count(self): if hasattr(self, '_m_has_field_ranged_bucket_count'): return self._m_has_field_ranged_bucket_count self._m_has_field_ranged_bucket_count = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ranged_bucket_count', None) @property def has_field_ranged_bucket_cd(self): if hasattr(self, '_m_has_field_ranged_bucket_cd'): return self._m_has_field_ranged_bucket_cd self._m_has_field_ranged_bucket_cd = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ranged_bucket_cd', None) class KvpOfDictAuxTypesStringArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) class ConfigAiCombatFollowMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_distance: self.start_distance = self._io.read_f4le() if self.has_field_stop_distance: self.stop_distance = self._io.read_f4le() if self.has_field_middle_distance: self.middle_distance = self._io.read_f4le() if self.has_field_inner_distance: self.inner_distance = self._io.read_f4le() if self.has_field_speed_level_outer: self.speed_level_outer = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_speed_level_middle: self.speed_level_middle = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_speed_level_inner: self.speed_level_inner = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_start_angle: self.start_angle = self._io.read_f4le() if self.has_field_outer_angle: self.outer_angle = self._io.read_f4le() if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_turn_speed_override_outer: self.turn_speed_override_outer = self._io.read_f4le() if self.has_field_use_melee_slot: self.use_melee_slot = self._io.read_u1() if self.has_field_move_out_damp_range: self.move_out_damp_range = self._io.read_f4le() @property def has_field_speed_level_inner(self): if hasattr(self, '_m_has_field_speed_level_inner'): return self._m_has_field_speed_level_inner self._m_has_field_speed_level_inner = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_speed_level_inner', None) @property def has_field_speed_level_outer(self): if hasattr(self, '_m_has_field_speed_level_outer'): return self._m_has_field_speed_level_outer self._m_has_field_speed_level_outer = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_speed_level_outer', None) @property def has_field_outer_angle(self): if hasattr(self, '_m_has_field_outer_angle'): return self._m_has_field_outer_angle self._m_has_field_outer_angle = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_outer_angle', None) @property def has_field_move_out_damp_range(self): if hasattr(self, '_m_has_field_move_out_damp_range'): return self._m_has_field_move_out_damp_range self._m_has_field_move_out_damp_range = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_move_out_damp_range', None) @property def has_field_speed_level_middle(self): if hasattr(self, '_m_has_field_speed_level_middle'): return self._m_has_field_speed_level_middle self._m_has_field_speed_level_middle = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_speed_level_middle', None) @property def has_field_middle_distance(self): if hasattr(self, '_m_has_field_middle_distance'): return self._m_has_field_middle_distance self._m_has_field_middle_distance = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_middle_distance', None) @property def has_field_turn_speed_override_outer(self): if hasattr(self, '_m_has_field_turn_speed_override_outer'): return self._m_has_field_turn_speed_override_outer self._m_has_field_turn_speed_override_outer = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_turn_speed_override_outer', None) @property def has_field_use_melee_slot(self): if hasattr(self, '_m_has_field_use_melee_slot'): return self._m_has_field_use_melee_slot self._m_has_field_use_melee_slot = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_use_melee_slot', None) @property def has_field_stop_distance(self): if hasattr(self, '_m_has_field_stop_distance'): return self._m_has_field_stop_distance self._m_has_field_stop_distance = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_stop_distance', None) @property def has_field_start_angle(self): if hasattr(self, '_m_has_field_start_angle'): return self._m_has_field_start_angle self._m_has_field_start_angle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_start_angle', None) @property def has_field_start_distance(self): if hasattr(self, '_m_has_field_start_distance'): return self._m_has_field_start_distance self._m_has_field_start_distance = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_start_distance', None) @property def has_field_inner_distance(self): if hasattr(self, '_m_has_field_inner_distance'): return self._m_has_field_inner_distance self._m_has_field_inner_distance = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_inner_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ConfigAnimGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dynamic_anime_map: self.dynamic_anime_map = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeU(self._io, self, self._root) @property def has_field_dynamic_anime_map(self): if hasattr(self, '_m_has_field_dynamic_anime_map'): return self._m_has_field_dynamic_anime_map self._m_has_field_dynamic_anime_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dynamic_anime_map', None) class MaterialExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySummerTimeRacePreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EchoShellPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCameraSplineBezierPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBasePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_in_control_point: self.in_control_point = Output.Vector(self._io, self, self._root) if self.has_field_out_control_point: self.out_control_point = Output.Vector(self._io, self, self._root) @property def t_list(self): if hasattr(self, '_m_t_list'): return self._m_t_list self._m_t_list = self.base.t_list return getattr(self, '_m_t_list', None) @property def position(self): if hasattr(self, '_m_position'): return self._m_position self._m_position = self.base.position return getattr(self, '_m_position', None) @property def dutch(self): if hasattr(self, '_m_dutch'): return self._m_dutch self._m_dutch = self.base.dutch return getattr(self, '_m_dutch', None) @property def euler_angle(self): if hasattr(self, '_m_euler_angle'): return self._m_euler_angle self._m_euler_angle = self.base.euler_angle return getattr(self, '_m_euler_angle', None) @property def s_list(self): if hasattr(self, '_m_s_list'): return self._m_s_list self._m_s_list = self.base.s_list return getattr(self, '_m_s_list', None) @property def length_ratio(self): if hasattr(self, '_m_length_ratio'): return self._m_length_ratio self._m_length_ratio = self.base.length_ratio return getattr(self, '_m_length_ratio', None) @property def has_field_in_control_point(self): if hasattr(self, '_m_has_field_in_control_point'): return self._m_has_field_in_control_point self._m_has_field_in_control_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_in_control_point', None) @property def has_field_out_control_point(self): if hasattr(self, '_m_has_field_out_control_point'): return self._m_has_field_out_control_point self._m_has_field_out_control_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_out_control_point', None) class TrialAvatarExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumPerfRatingCategoryEnumPerfRatingCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPerfRatingCategoryEnumPerfRatingCategory(self._io, self, self._root)) class EnumLevelBuffSpecial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LevelBuffSpecial, self.data.value) return getattr(self, '_m_value', None) class DailyTaskCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiScriptedMoveToData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is3d: self.is3d = self._io.read_u1() if self.has_field_stop_by_obstacle: self.stop_by_obstacle = self._io.read_u1() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_is3d(self): if hasattr(self, '_m_has_field_is3d'): return self._m_has_field_is3d self._m_has_field_is3d = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is3d', None) @property def has_field_stop_by_obstacle(self): if hasattr(self, '_m_has_field_stop_by_obstacle'): return self._m_has_field_stop_by_obstacle self._m_has_field_stop_by_obstacle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_stop_by_obstacle', None) class PhotographTaskTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AchievementGoalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order_id: self.order_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_reward_id: self.finish_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) @property def has_field_order_id(self): if hasattr(self, '_m_has_field_order_id'): return self._m_has_field_order_id self._m_has_field_order_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_order_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_finish_reward_id(self): if hasattr(self, '_m_has_field_finish_reward_id'): return self._m_has_field_finish_reward_id self._m_has_field_finish_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_finish_reward_id', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ByBigTeamHasWeaponType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weapon_type: self.weapon_type = AuxTypes.String(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_weapon_type(self): if hasattr(self, '_m_has_field_weapon_type'): return self._m_has_field_weapon_type self._m_has_field_weapon_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weapon_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigAbilityNodeFilterData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_runtime_i_ds: self.runtime_i_ds = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_distance: self.distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_config_i_ds: self.config_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ability_names: self.ability_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_modifier_names: self.modifier_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_ability_names(self): if hasattr(self, '_m_has_field_ability_names'): return self._m_has_field_ability_names self._m_has_field_ability_names = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ability_names', None) @property def has_field_config_i_ds(self): if hasattr(self, '_m_has_field_config_i_ds'): return self._m_has_field_config_i_ds self._m_has_field_config_i_ds = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_config_i_ds', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_distance', None) @property def has_field_modifier_names(self): if hasattr(self, '_m_has_field_modifier_names'): return self._m_has_field_modifier_names self._m_has_field_modifier_names = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_modifier_names', None) @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_entity_types', None) @property def has_field_runtime_i_ds(self): if hasattr(self, '_m_has_field_runtime_i_ds'): return self._m_has_field_runtime_i_ds self._m_has_field_runtime_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_runtime_i_ds', None) class OptionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GuideRatingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigSkin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigSkin(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigMonsterSkin(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class KvpOfDictAuxTypesVlqBase128LeUConfigWidgetGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigWidgetGadget(self._io, self, self._root) class EnumIndicatorOperator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IndicatorOperator, self.data.value) return getattr(self, '_m_value', None) class RogueSequenceExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityStateResistanceByIdExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_states: self.ability_states = Output.ArrayOfEnumAbilityStateLengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_ability_states(self): if hasattr(self, '_m_has_field_ability_states'): return self._m_has_field_ability_states self._m_has_field_ability_states = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_ability_states', None) class ConfigAudioListener(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fake_avatar_distance: self.fake_avatar_distance = self._io.read_f4le() if self.has_field_ak_listener_height: self.ak_listener_height = self._io.read_f4le() if self.has_field_obstruction_rtpc: self.obstruction_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_focus_angle_rtpc: self.focus_angle_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_obstruction_detect_radius: self.obstruction_detect_radius = self._io.read_f4le() if self.has_field_outreach_cast: self.outreach_cast = Output.ConfigAudioListenerOutreachCast(self._io, self, self._root) if self.has_field_first_person_listener_volume_offset: self.first_person_listener_volume_offset = self._io.read_f4le() if self.has_field_third_person_listener_volume_offset: self.third_person_listener_volume_offset = self._io.read_f4le() if self.has_field_default_listener_volume_offset: self.default_listener_volume_offset = self._io.read_f4le() @property def has_field_obstruction_detect_radius(self): if hasattr(self, '_m_has_field_obstruction_detect_radius'): return self._m_has_field_obstruction_detect_radius self._m_has_field_obstruction_detect_radius = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_obstruction_detect_radius', None) @property def has_field_outreach_cast(self): if hasattr(self, '_m_has_field_outreach_cast'): return self._m_has_field_outreach_cast self._m_has_field_outreach_cast = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_outreach_cast', None) @property def has_field_focus_angle_rtpc(self): if hasattr(self, '_m_has_field_focus_angle_rtpc'): return self._m_has_field_focus_angle_rtpc self._m_has_field_focus_angle_rtpc = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_focus_angle_rtpc', None) @property def has_field_first_person_listener_volume_offset(self): if hasattr(self, '_m_has_field_first_person_listener_volume_offset'): return self._m_has_field_first_person_listener_volume_offset self._m_has_field_first_person_listener_volume_offset = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_first_person_listener_volume_offset', None) @property def has_field_third_person_listener_volume_offset(self): if hasattr(self, '_m_has_field_third_person_listener_volume_offset'): return self._m_has_field_third_person_listener_volume_offset self._m_has_field_third_person_listener_volume_offset = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_third_person_listener_volume_offset', None) @property def has_field_fake_avatar_distance(self): if hasattr(self, '_m_has_field_fake_avatar_distance'): return self._m_has_field_fake_avatar_distance self._m_has_field_fake_avatar_distance = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_fake_avatar_distance', None) @property def has_field_obstruction_rtpc(self): if hasattr(self, '_m_has_field_obstruction_rtpc'): return self._m_has_field_obstruction_rtpc self._m_has_field_obstruction_rtpc = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_obstruction_rtpc', None) @property def has_field_ak_listener_height(self): if hasattr(self, '_m_has_field_ak_listener_height'): return self._m_has_field_ak_listener_height self._m_has_field_ak_listener_height = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_ak_listener_height', None) @property def has_field_default_listener_volume_offset(self): if hasattr(self, '_m_has_field_default_listener_volume_offset'): return self._m_has_field_default_listener_volume_offset self._m_has_field_default_listener_volume_offset = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_default_listener_volume_offset', None) class RoutineTypeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEntityActionTokenGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_low_entity_token: self.low_entity_token = Output.ConfigAbilityActionToken(self._io, self, self._root) if self.has_field_other_entity_token: self.other_entity_token = Output.ConfigAbilityActionToken(self._io, self, self._root) if self.has_field_use_high_entity_types: self.use_high_entity_types = self._io.read_u1() @property def has_field_low_entity_token(self): if hasattr(self, '_m_has_field_low_entity_token'): return self._m_has_field_low_entity_token self._m_has_field_low_entity_token = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_low_entity_token', None) @property def has_field_other_entity_token(self): if hasattr(self, '_m_has_field_other_entity_token'): return self._m_has_field_other_entity_token self._m_has_field_other_entity_token = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_other_entity_token', None) @property def has_field_use_high_entity_types(self): if hasattr(self, '_m_has_field_use_high_entity_types'): return self._m_has_field_use_high_entity_types self._m_has_field_use_high_entity_types = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_high_entity_types', None) class RogueTokenExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AirFlowMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_target_type: self.camp_target_type = Output.EnumTargetType(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_camp_id', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_camp_target_type(self): if hasattr(self, '_m_has_field_camp_target_type'): return self._m_has_field_camp_target_type self._m_has_field_camp_target_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camp_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_born', None) class MichiaeMatsuriRadarMarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryRoomExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictEnumSceneBuildingTypeEnumMarkIconType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumSceneBuildingType(self._io, self, self._root) self.value = Output.EnumMarkIconType(self._io, self, self._root) class EnumActionSlotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionSlotType, self.data.value) return getattr(self, '_m_value', None) class RogueDungeonCellExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cell_id: self.cell_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cell_center_pos: self.cell_center_pos = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_map_coordinate: self.map_coordinate = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_adjacency_cell_list: self.adjacency_cell_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight_id: self.weight_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_operator_delta_y: self.operator_delta_y = self._io.read_f4le() if self.has_field_door_offset: self.door_offset = self._io.read_f4le() if self.has_field_special_type: self.special_type = Output.EnumRogueCellType(self._io, self, self._root) if self.has_field_door_delta_y: self.door_delta_y = self._io.read_f4le() if self.has_field_is_init_cell: self.is_init_cell = self._io.read_u1() @property def has_field_door_delta_y(self): if hasattr(self, '_m_has_field_door_delta_y'): return self._m_has_field_door_delta_y self._m_has_field_door_delta_y = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_door_delta_y', None) @property def has_field_cell_center_pos(self): if hasattr(self, '_m_has_field_cell_center_pos'): return self._m_has_field_cell_center_pos self._m_has_field_cell_center_pos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cell_center_pos', None) @property def has_field_map_coordinate(self): if hasattr(self, '_m_has_field_map_coordinate'): return self._m_has_field_map_coordinate self._m_has_field_map_coordinate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_map_coordinate', None) @property def has_field_special_type(self): if hasattr(self, '_m_has_field_special_type'): return self._m_has_field_special_type self._m_has_field_special_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_special_type', None) @property def has_field_weight_id(self): if hasattr(self, '_m_has_field_weight_id'): return self._m_has_field_weight_id self._m_has_field_weight_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_weight_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_operator_delta_y(self): if hasattr(self, '_m_has_field_operator_delta_y'): return self._m_has_field_operator_delta_y self._m_has_field_operator_delta_y = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_operator_delta_y', None) @property def has_field_is_init_cell(self): if hasattr(self, '_m_has_field_is_init_cell'): return self._m_has_field_is_init_cell self._m_has_field_is_init_cell = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_init_cell', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_cell_id(self): if hasattr(self, '_m_has_field_cell_id'): return self._m_has_field_cell_id self._m_has_field_cell_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cell_id', None) @property def has_field_door_offset(self): if hasattr(self, '_m_has_field_door_offset'): return self._m_has_field_door_offset self._m_has_field_door_offset = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_door_offset', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_adjacency_cell_list(self): if hasattr(self, '_m_has_field_adjacency_cell_list'): return self._m_has_field_adjacency_cell_list self._m_has_field_adjacency_cell_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_adjacency_cell_list', None) class EnumMovePlatformDelayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MovePlatformDelayType, self.data.value) return getattr(self, '_m_value', None) class GatherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_type: self.point_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_item_id_vec: self.extra_item_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_point_location: self.point_location = Output.EnumPointLocation(self._io, self, self._root) if self.has_field_cd: self.cd = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_id: self.refresh_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_block_limits: self.block_limits = Output.ArrayOfBlockLimitLengthS(self._io, self, self._root) if self.has_field_init_disable_interact: self.init_disable_interact = self._io.read_u1() if self.has_field_is_forbid_guest: self.is_forbid_guest = self._io.read_u1() if self.has_field_save_type: self.save_type = Output.EnumGatherSaveType(self._io, self, self._root) if self.has_field_is_forbid_mp_mode: self.is_forbid_mp_mode = self._io.read_u1() @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cd', None) @property def has_field_save_type(self): if hasattr(self, '_m_has_field_save_type'): return self._m_has_field_save_type self._m_has_field_save_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_save_type', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_point_type', None) @property def has_field_init_disable_interact(self): if hasattr(self, '_m_has_field_init_disable_interact'): return self._m_has_field_init_disable_interact self._m_has_field_init_disable_interact = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_init_disable_interact', None) @property def has_field_is_forbid_guest(self): if hasattr(self, '_m_has_field_is_forbid_guest'): return self._m_has_field_is_forbid_guest self._m_has_field_is_forbid_guest = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_is_forbid_guest', None) @property def has_field_point_location(self): if hasattr(self, '_m_has_field_point_location'): return self._m_has_field_point_location self._m_has_field_point_location = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_point_location', None) @property def has_field_is_forbid_mp_mode(self): if hasattr(self, '_m_has_field_is_forbid_mp_mode'): return self._m_has_field_is_forbid_mp_mode self._m_has_field_is_forbid_mp_mode = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_is_forbid_mp_mode', None) @property def has_field_block_limits(self): if hasattr(self, '_m_has_field_block_limits'): return self._m_has_field_block_limits self._m_has_field_block_limits = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_block_limits', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_refresh_id(self): if hasattr(self, '_m_has_field_refresh_id'): return self._m_has_field_refresh_id self._m_has_field_refresh_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_refresh_id', None) @property def has_field_extra_item_id_vec(self): if hasattr(self, '_m_has_field_extra_item_id_vec'): return self._m_has_field_extra_item_id_vec self._m_has_field_extra_item_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_extra_item_id_vec', None) class SalvageChallengeDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCustomGadgetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CustomGadgetType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigPerformanceSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerformanceSetting(self._io, self, self._root)) class ConfigWidgetToyBonfire(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cool_down: self.cool_down = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lasting_time: self.lasting_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_in_scene: self.max_count_in_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count_by_player: self.max_count_by_player = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_combat_destroy_distance: self.combat_destroy_distance = self._io.read_f4le() @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_cool_down(self): if hasattr(self, '_m_has_field_cool_down'): return self._m_has_field_cool_down self._m_has_field_cool_down = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cool_down', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_max_count_by_player(self): if hasattr(self, '_m_has_field_max_count_by_player'): return self._m_has_field_max_count_by_player self._m_has_field_max_count_by_player = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_count_by_player', None) @property def has_field_lasting_time(self): if hasattr(self, '_m_has_field_lasting_time'): return self._m_has_field_lasting_time self._m_has_field_lasting_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lasting_time', None) @property def has_field_combat_destroy_distance(self): if hasattr(self, '_m_has_field_combat_destroy_distance'): return self._m_has_field_combat_destroy_distance self._m_has_field_combat_destroy_distance = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_combat_destroy_distance', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_max_count_in_scene(self): if hasattr(self, '_m_has_field_max_count_in_scene'): return self._m_has_field_max_count_in_scene self._m_has_field_max_count_in_scene = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_count_in_scene', None) class LuminanceStoneChallengeOverallExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root)) class ConfigWidgetLightStone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_energy_limit_array: self.level_energy_limit_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_cd_group_id_array: self.level_cd_group_id_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quick_use_open_level: self.quick_use_open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sky_crystal_detector_open_level: self.sky_crystal_detector_open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_energy_type: self.energy_type = Output.EnumRegionalPlayVarType(self._io, self, self._root) if self.has_field_gadget_chain_id: self.gadget_chain_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quick_use_cost_energy: self.quick_use_cost_energy = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_ability_name: self.trigger_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_team: self.is_team = self._io.read_u1() if self.has_field_hint_radius: self.hint_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_nearby_radius: self.nearby_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_grid_search_range: self.grid_search_range = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_success_gadget_id: self.success_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_failed_gadget_id: self.failed_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gather_point_type: self.gather_point_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hint_group: self.hint_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_last_time: self.effect_last_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_distance_to_avatar: self.distance_to_avatar = self._io.read_f4le() if self.has_field_height: self.height = self._io.read_f4le() @property def has_field_success_gadget_id(self): if hasattr(self, '_m_has_field_success_gadget_id'): return self._m_has_field_success_gadget_id self._m_has_field_success_gadget_id = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_success_gadget_id', None) @property def has_field_nearby_radius(self): if hasattr(self, '_m_has_field_nearby_radius'): return self._m_has_field_nearby_radius self._m_has_field_nearby_radius = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_nearby_radius', None) @property def has_field_hint_group(self): if hasattr(self, '_m_has_field_hint_group'): return self._m_has_field_hint_group self._m_has_field_hint_group = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_hint_group', None) @property def has_field_height(self): if hasattr(self, '_m_has_field_height'): return self._m_has_field_height self._m_has_field_height = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_height', None) @property def has_field_is_team(self): if hasattr(self, '_m_has_field_is_team'): return self._m_has_field_is_team self._m_has_field_is_team = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_is_team', None) @property def has_field_effect_last_time(self): if hasattr(self, '_m_has_field_effect_last_time'): return self._m_has_field_effect_last_time self._m_has_field_effect_last_time = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_effect_last_time', None) @property def has_field_gather_point_type(self): if hasattr(self, '_m_has_field_gather_point_type'): return self._m_has_field_gather_point_type self._m_has_field_gather_point_type = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_gather_point_type', None) @property def has_field_quick_use_open_level(self): if hasattr(self, '_m_has_field_quick_use_open_level'): return self._m_has_field_quick_use_open_level self._m_has_field_quick_use_open_level = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_quick_use_open_level', None) @property def has_field_trigger_ability_name(self): if hasattr(self, '_m_has_field_trigger_ability_name'): return self._m_has_field_trigger_ability_name self._m_has_field_trigger_ability_name = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_trigger_ability_name', None) @property def has_field_quick_use_cost_energy(self): if hasattr(self, '_m_has_field_quick_use_cost_energy'): return self._m_has_field_quick_use_cost_energy self._m_has_field_quick_use_cost_energy = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_quick_use_cost_energy', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def has_field_sky_crystal_detector_open_level(self): if hasattr(self, '_m_has_field_sky_crystal_detector_open_level'): return self._m_has_field_sky_crystal_detector_open_level self._m_has_field_sky_crystal_detector_open_level = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_sky_crystal_detector_open_level', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def has_field_hint_radius(self): if hasattr(self, '_m_has_field_hint_radius'): return self._m_has_field_hint_radius self._m_has_field_hint_radius = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_hint_radius', None) @property def has_field_grid_search_range(self): if hasattr(self, '_m_has_field_grid_search_range'): return self._m_has_field_grid_search_range self._m_has_field_grid_search_range = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_grid_search_range', None) @property def has_field_gadget_chain_id(self): if hasattr(self, '_m_has_field_gadget_chain_id'): return self._m_has_field_gadget_chain_id self._m_has_field_gadget_chain_id = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_gadget_chain_id', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_distance_to_avatar(self): if hasattr(self, '_m_has_field_distance_to_avatar'): return self._m_has_field_distance_to_avatar self._m_has_field_distance_to_avatar = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_distance_to_avatar', None) @property def has_field_energy_type(self): if hasattr(self, '_m_has_field_energy_type'): return self._m_has_field_energy_type self._m_has_field_energy_type = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_energy_type', None) @property def has_field_level_energy_limit_array(self): if hasattr(self, '_m_has_field_level_energy_limit_array'): return self._m_has_field_level_energy_limit_array self._m_has_field_level_energy_limit_array = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_level_energy_limit_array', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def has_field_failed_gadget_id(self): if hasattr(self, '_m_has_field_failed_gadget_id'): return self._m_has_field_failed_gadget_id self._m_has_field_failed_gadget_id = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_failed_gadget_id', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def has_field_level_cd_group_id_array(self): if hasattr(self, '_m_has_field_level_cd_group_id_array'): return self._m_has_field_level_cd_group_id_array self._m_has_field_level_cd_group_id_array = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_level_cd_group_id_array', None) class ConfigBattleFervorFactorByMonster(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorFactor(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_triggers: self.triggers = Output.ArrayOfConfigBattleFervorUpdateTriggerByMonsterLengthU(self._io, self, self._root) @property def has_field_triggers(self): if hasattr(self, '_m_has_field_triggers'): return self._m_has_field_triggers self._m_has_field_triggers = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_triggers', None) @property def factor_min_value(self): if hasattr(self, '_m_factor_min_value'): return self._m_factor_min_value self._m_factor_min_value = self.base.factor_min_value return getattr(self, '_m_factor_min_value', None) @property def factor_max_value(self): if hasattr(self, '_m_factor_max_value'): return self._m_factor_max_value self._m_factor_max_value = self.base.factor_max_value return getattr(self, '_m_factor_max_value', None) @property def factor_init_value(self): if hasattr(self, '_m_factor_init_value'): return self._m_factor_init_value self._m_factor_init_value = self.base.factor_init_value return getattr(self, '_m_factor_init_value', None) class DispConfigGadgetTurn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigGadgetTurn(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGlobalValueTurn(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class FetterStoryExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideTheatreMechanicusBuildingSelectCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_rebuild: self.is_rebuild = self._io.read_u1() if self.has_field_is_select: self.is_select = self._io.read_u1() @property def has_field_is_rebuild(self): if hasattr(self, '_m_has_field_is_rebuild'): return self._m_has_field_is_rebuild self._m_has_field_is_rebuild = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_rebuild', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_select(self): if hasattr(self, '_m_has_field_is_select'): return self._m_has_field_is_select self._m_has_field_is_select = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_select', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class ChallengeEventMarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBattleFervorUpdatePredicateLocalAvatarInBattle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdatePredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_update_in_battle: self.is_update_in_battle = self._io.read_u1() @property def has_field_is_update_in_battle(self): if hasattr(self, '_m_has_field_is_update_in_battle'): return self._m_has_field_is_update_in_battle self._m_has_field_is_update_in_battle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_update_in_battle', None) class DictOfAuxTypesVlqBase128LeUCoopSubStartPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUCoopSubStartPoint(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeUDispConfigCoopBaseNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.DispConfigCoopBaseNode(self._io, self, self._root) class ConfigGuideDelayDoAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_delay_time: self.delay_time = self._io.read_f4le() if self.has_field_actions: self.actions = Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root) @property def has_field_delay_time(self): if hasattr(self, '_m_has_field_delay_time'): return self._m_has_field_delay_time self._m_has_field_delay_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_delay_time', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) class GadgetGuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShapeCube(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseShape(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_width: self.width = self._io.read_f4le() if self.has_field_length: self.length = self._io.read_f4le() @property def height(self): if hasattr(self, '_m_height'): return self._m_height self._m_height = self.base.height return getattr(self, '_m_height', None) @property def height_type(self): if hasattr(self, '_m_height_type'): return self._m_height_type self._m_height_type = self.base.height_type return getattr(self, '_m_height_type', None) @property def use_height(self): if hasattr(self, '_m_use_height'): return self._m_use_height self._m_use_height = self.base.use_height return getattr(self, '_m_use_height', None) @property def has_field_width(self): if hasattr(self, '_m_has_field_width'): return self._m_has_field_width self._m_has_field_width = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_width', None) @property def has_field_length(self): if hasattr(self, '_m_has_field_length'): return self._m_has_field_length self._m_has_field_length = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_length', None) class ContextActionSelectMonsterMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_track: self.need_track = self._io.read_u1() @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_monster_id', None) @property def has_field_need_track(self): if hasattr(self, '_m_has_field_need_track'): return self._m_has_field_need_track self._m_has_field_need_track = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_need_track', None) class EnumBlessingScanType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlessingScanType, self.data.value) return getattr(self, '_m_value', None) class InteractActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MaterialSourceDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_list: self.dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_jump_list: self.jump_list = Output.ArrayOfSourceJumpConfigLengthS(self._io, self, self._root) if self.has_field_dungeon_group: self.dungeon_group = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_jump_targets: self.jump_targets = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_jump_params: self.jump_params = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_jump_descs: self.jump_descs = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_text_list: self.text_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_jump_targets(self): if hasattr(self, '_m_has_field_jump_targets'): return self._m_has_field_jump_targets self._m_has_field_jump_targets = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_jump_targets', None) @property def has_field_dungeon_list(self): if hasattr(self, '_m_has_field_dungeon_list'): return self._m_has_field_dungeon_list self._m_has_field_dungeon_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_list', None) @property def has_field_jump_descs(self): if hasattr(self, '_m_has_field_jump_descs'): return self._m_has_field_jump_descs self._m_has_field_jump_descs = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_jump_descs', None) @property def has_field_jump_params(self): if hasattr(self, '_m_has_field_jump_params'): return self._m_has_field_jump_params self._m_has_field_jump_params = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_jump_params', None) @property def has_field_dungeon_group(self): if hasattr(self, '_m_has_field_dungeon_group'): return self._m_has_field_dungeon_group self._m_has_field_dungeon_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dungeon_group', None) @property def has_field_jump_list(self): if hasattr(self, '_m_has_field_jump_list'): return self._m_has_field_jump_list self._m_has_field_jump_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_jump_list', None) @property def has_field_text_list(self): if hasattr(self, '_m_has_field_text_list'): return self._m_has_field_text_list self._m_has_field_text_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_text_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ProductPlayDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumProductPlayType(self._io, self, self._root) if self.has_field_item_name: self.item_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_item_name(self): if hasattr(self, '_m_has_field_item_name'): return self._m_has_field_item_name self._m_has_field_item_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_name', None) class DispConfigJudgeNodeBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 10: self.data = Output.ConfigJudgeGroupEntityDirectionHasBlock(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigJudgeNodeBase(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigJudgeEntityInViewByEntityConfigId(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigJudgeAvatarWeaponType(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigJudgeAvatarFaceCamera(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigJudgeGroupEntityInView(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigJudgeNodeContainerWithGroupEntityInfo(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigJudgeAvatarConfigId(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigJudgeNodeContainer(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigJudgeMoonOrSunInCamera(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigJudgeAvatarElementType(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigJudgeAvatarFaceTarget2d(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigJudgeAvatarAnimatorState(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigJudgeCurrentTime(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigSpatialSphereRoomTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_radius', None) class ConfigLevelNavmeshPolygon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_polygon_id: self.polygon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_polygon: self.polygon = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_polygon_min_y: self.polygon_min_y = self._io.read_f4le() if self.has_field_polygon_max_y: self.polygon_max_y = self._io.read_f4le() if self.has_field_all_scene_tag_i_ds: self.all_scene_tag_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_scene_tags_hash_list: self.scene_tags_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_all_scene_tag_i_ds(self): if hasattr(self, '_m_has_field_all_scene_tag_i_ds'): return self._m_has_field_all_scene_tag_i_ds self._m_has_field_all_scene_tag_i_ds = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_all_scene_tag_i_ds', None) @property def has_field_scene_tags_hash_list(self): if hasattr(self, '_m_has_field_scene_tags_hash_list'): return self._m_has_field_scene_tags_hash_list self._m_has_field_scene_tags_hash_list = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_scene_tags_hash_list', None) @property def has_field_polygon_min_y(self): if hasattr(self, '_m_has_field_polygon_min_y'): return self._m_has_field_polygon_min_y self._m_has_field_polygon_min_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_polygon_min_y', None) @property def has_field_polygon_id(self): if hasattr(self, '_m_has_field_polygon_id'): return self._m_has_field_polygon_id self._m_has_field_polygon_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_polygon_id', None) @property def has_field_polygon_max_y(self): if hasattr(self, '_m_has_field_polygon_max_y'): return self._m_has_field_polygon_max_y self._m_has_field_polygon_max_y = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_polygon_max_y', None) @property def has_field_polygon(self): if hasattr(self, '_m_has_field_polygon'): return self._m_has_field_polygon self._m_has_field_polygon = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_polygon', None) class IrodoriPoetryLineExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHdrSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_luminosity: self.max_luminosity = self._io.read_f4le() if self.has_field_min_max_luminosity: self.min_max_luminosity = self._io.read_f4le() if self.has_field_max_max_luminosity: self.max_max_luminosity = self._io.read_f4le() if self.has_field_step_max_luminosity: self.step_max_luminosity = self._io.read_f4le() if self.has_field_ui_paper_white: self.ui_paper_white = self._io.read_f4le() if self.has_field_min_ui_paper_white: self.min_ui_paper_white = self._io.read_f4le() if self.has_field_max_ui_paper_white: self.max_ui_paper_white = self._io.read_f4le() if self.has_field_step_ui_paper_white: self.step_ui_paper_white = self._io.read_f4le() if self.has_field_scene_paper_white: self.scene_paper_white = self._io.read_f4le() if self.has_field_min_scene_paper_white: self.min_scene_paper_white = self._io.read_f4le() if self.has_field_max_scene_paper_white: self.max_scene_paper_white = self._io.read_f4le() if self.has_field_step_scene_paper_white: self.step_scene_paper_white = self._io.read_f4le() @property def has_field_ui_paper_white(self): if hasattr(self, '_m_has_field_ui_paper_white'): return self._m_has_field_ui_paper_white self._m_has_field_ui_paper_white = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_ui_paper_white', None) @property def has_field_step_ui_paper_white(self): if hasattr(self, '_m_has_field_step_ui_paper_white'): return self._m_has_field_step_ui_paper_white self._m_has_field_step_ui_paper_white = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_step_ui_paper_white', None) @property def has_field_min_max_luminosity(self): if hasattr(self, '_m_has_field_min_max_luminosity'): return self._m_has_field_min_max_luminosity self._m_has_field_min_max_luminosity = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_min_max_luminosity', None) @property def has_field_max_luminosity(self): if hasattr(self, '_m_has_field_max_luminosity'): return self._m_has_field_max_luminosity self._m_has_field_max_luminosity = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_max_luminosity', None) @property def has_field_step_scene_paper_white(self): if hasattr(self, '_m_has_field_step_scene_paper_white'): return self._m_has_field_step_scene_paper_white self._m_has_field_step_scene_paper_white = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_step_scene_paper_white', None) @property def has_field_max_max_luminosity(self): if hasattr(self, '_m_has_field_max_max_luminosity'): return self._m_has_field_max_max_luminosity self._m_has_field_max_max_luminosity = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_max_max_luminosity', None) @property def has_field_max_scene_paper_white(self): if hasattr(self, '_m_has_field_max_scene_paper_white'): return self._m_has_field_max_scene_paper_white self._m_has_field_max_scene_paper_white = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_max_scene_paper_white', None) @property def has_field_min_ui_paper_white(self): if hasattr(self, '_m_has_field_min_ui_paper_white'): return self._m_has_field_min_ui_paper_white self._m_has_field_min_ui_paper_white = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_min_ui_paper_white', None) @property def has_field_scene_paper_white(self): if hasattr(self, '_m_has_field_scene_paper_white'): return self._m_has_field_scene_paper_white self._m_has_field_scene_paper_white = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_scene_paper_white', None) @property def has_field_min_scene_paper_white(self): if hasattr(self, '_m_has_field_min_scene_paper_white'): return self._m_has_field_min_scene_paper_white self._m_has_field_min_scene_paper_white = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_min_scene_paper_white', None) @property def has_field_max_ui_paper_white(self): if hasattr(self, '_m_has_field_max_ui_paper_white'): return self._m_has_field_max_ui_paper_white self._m_has_field_max_ui_paper_white = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_max_ui_paper_white', None) @property def has_field_step_max_luminosity(self): if hasattr(self, '_m_has_field_step_max_luminosity'): return self._m_has_field_step_max_luminosity self._m_has_field_step_max_luminosity = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_step_max_luminosity', None) class ArrayOfLanV2projectionElementConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.LanV2projectionElementConfig(self._io, self, self._root)) class EnumInterPriorityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InterPriorityType, self.data.value) return getattr(self, '_m_value', None) class EmotionTemplateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BirthdayMailExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriChessCardEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumIrodoriChessCardTargetType(self._io, self, self._root) if self.has_field_target_param_list: self.target_param_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumIrodoriChessCardEffectType(self._io, self, self._root) if self.has_field_effect_str_param: self.effect_str_param = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_param1: self.effect_param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param2: self.effect_param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_param3: self.effect_param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_index: self.effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_effect_str_param(self): if hasattr(self, '_m_has_field_effect_str_param'): return self._m_has_field_effect_str_param self._m_has_field_effect_str_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_effect_str_param', None) @property def has_field_effect_param3(self): if hasattr(self, '_m_has_field_effect_param3'): return self._m_has_field_effect_param3 self._m_has_field_effect_param3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_effect_param3', None) @property def has_field_effect_param1(self): if hasattr(self, '_m_has_field_effect_param1'): return self._m_has_field_effect_param1 self._m_has_field_effect_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effect_param1', None) @property def has_field_target_param_list(self): if hasattr(self, '_m_has_field_target_param_list'): return self._m_has_field_target_param_list self._m_has_field_target_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_target_param_list', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_target_type', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_effect_index', None) @property def has_field_effect_param2(self): if hasattr(self, '_m_has_field_effect_param2'): return self._m_has_field_effect_param2 self._m_has_field_effect_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_param2', None) class ConfigAudioAvatarMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fly_direction_rtpc_key: self.fly_direction_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_fly_direction_rtpc_front: self.fly_direction_rtpc_front = self._io.read_f4le() if self.has_field_fly_direction_rtpc_side: self.fly_direction_rtpc_side = self._io.read_f4le() if self.has_field_fly_direction_rtpc_back: self.fly_direction_rtpc_back = self._io.read_f4le() if self.has_field_fly_direction_rtpc_drop: self.fly_direction_rtpc_drop = self._io.read_f4le() if self.has_field_last_frame_speed_in_air_rtpc_key: self.last_frame_speed_in_air_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_event_fall_in_water: self.event_fall_in_water = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_altitude_rtpc_key: self.altitude_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_slope_rtpc_key: self.slope_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_fly_turn_event: self.fly_turn_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_fly_turn_event_interval: self.fly_turn_event_interval = self._io.read_f4le() if self.has_field_fly_speed_rtpc_key: self.fly_speed_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_airflow_speed_gain: self.airflow_speed_gain = self._io.read_f4le() if self.has_field_airflow_gain_fade_length: self.airflow_gain_fade_length = self._io.read_f4le() if self.has_field_climb_vertical_scaler_rtpc_key: self.climb_vertical_scaler_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_climb_vertical_scaler_animator_key: self.climb_vertical_scaler_animator_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_camera_angle_x_rtpc_key: self.camera_angle_x_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_camera_angle_y_rtpc_key: self.camera_angle_y_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_enter_speedup_field_event: self.enter_speedup_field_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_fall_on_water_rtpc_key: self.fall_on_water_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_fly_direction_rtpc_front(self): if hasattr(self, '_m_has_field_fly_direction_rtpc_front'): return self._m_has_field_fly_direction_rtpc_front self._m_has_field_fly_direction_rtpc_front = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_fly_direction_rtpc_front', None) @property def has_field_fall_on_water_rtpc_key(self): if hasattr(self, '_m_has_field_fall_on_water_rtpc_key'): return self._m_has_field_fall_on_water_rtpc_key self._m_has_field_fall_on_water_rtpc_key = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_fall_on_water_rtpc_key', None) @property def has_field_fly_turn_event(self): if hasattr(self, '_m_has_field_fly_turn_event'): return self._m_has_field_fly_turn_event self._m_has_field_fly_turn_event = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_fly_turn_event', None) @property def has_field_camera_angle_x_rtpc_key(self): if hasattr(self, '_m_has_field_camera_angle_x_rtpc_key'): return self._m_has_field_camera_angle_x_rtpc_key self._m_has_field_camera_angle_x_rtpc_key = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_camera_angle_x_rtpc_key', None) @property def has_field_fly_turn_event_interval(self): if hasattr(self, '_m_has_field_fly_turn_event_interval'): return self._m_has_field_fly_turn_event_interval self._m_has_field_fly_turn_event_interval = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_fly_turn_event_interval', None) @property def has_field_event_fall_in_water(self): if hasattr(self, '_m_has_field_event_fall_in_water'): return self._m_has_field_event_fall_in_water self._m_has_field_event_fall_in_water = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_event_fall_in_water', None) @property def has_field_camera_angle_y_rtpc_key(self): if hasattr(self, '_m_has_field_camera_angle_y_rtpc_key'): return self._m_has_field_camera_angle_y_rtpc_key self._m_has_field_camera_angle_y_rtpc_key = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_camera_angle_y_rtpc_key', None) @property def has_field_slope_rtpc_key(self): if hasattr(self, '_m_has_field_slope_rtpc_key'): return self._m_has_field_slope_rtpc_key self._m_has_field_slope_rtpc_key = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_slope_rtpc_key', None) @property def has_field_fly_direction_rtpc_key(self): if hasattr(self, '_m_has_field_fly_direction_rtpc_key'): return self._m_has_field_fly_direction_rtpc_key self._m_has_field_fly_direction_rtpc_key = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_fly_direction_rtpc_key', None) @property def has_field_altitude_rtpc_key(self): if hasattr(self, '_m_has_field_altitude_rtpc_key'): return self._m_has_field_altitude_rtpc_key self._m_has_field_altitude_rtpc_key = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_altitude_rtpc_key', None) @property def has_field_fly_direction_rtpc_side(self): if hasattr(self, '_m_has_field_fly_direction_rtpc_side'): return self._m_has_field_fly_direction_rtpc_side self._m_has_field_fly_direction_rtpc_side = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_fly_direction_rtpc_side', None) @property def has_field_airflow_speed_gain(self): if hasattr(self, '_m_has_field_airflow_speed_gain'): return self._m_has_field_airflow_speed_gain self._m_has_field_airflow_speed_gain = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_airflow_speed_gain', None) @property def has_field_climb_vertical_scaler_rtpc_key(self): if hasattr(self, '_m_has_field_climb_vertical_scaler_rtpc_key'): return self._m_has_field_climb_vertical_scaler_rtpc_key self._m_has_field_climb_vertical_scaler_rtpc_key = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_climb_vertical_scaler_rtpc_key', None) @property def has_field_enter_speedup_field_event(self): if hasattr(self, '_m_has_field_enter_speedup_field_event'): return self._m_has_field_enter_speedup_field_event self._m_has_field_enter_speedup_field_event = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_enter_speedup_field_event', None) @property def has_field_fly_speed_rtpc_key(self): if hasattr(self, '_m_has_field_fly_speed_rtpc_key'): return self._m_has_field_fly_speed_rtpc_key self._m_has_field_fly_speed_rtpc_key = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_fly_speed_rtpc_key', None) @property def has_field_fly_direction_rtpc_back(self): if hasattr(self, '_m_has_field_fly_direction_rtpc_back'): return self._m_has_field_fly_direction_rtpc_back self._m_has_field_fly_direction_rtpc_back = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_fly_direction_rtpc_back', None) @property def has_field_climb_vertical_scaler_animator_key(self): if hasattr(self, '_m_has_field_climb_vertical_scaler_animator_key'): return self._m_has_field_climb_vertical_scaler_animator_key self._m_has_field_climb_vertical_scaler_animator_key = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_climb_vertical_scaler_animator_key', None) @property def has_field_fly_direction_rtpc_drop(self): if hasattr(self, '_m_has_field_fly_direction_rtpc_drop'): return self._m_has_field_fly_direction_rtpc_drop self._m_has_field_fly_direction_rtpc_drop = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_fly_direction_rtpc_drop', None) @property def has_field_airflow_gain_fade_length(self): if hasattr(self, '_m_has_field_airflow_gain_fade_length'): return self._m_has_field_airflow_gain_fade_length self._m_has_field_airflow_gain_fade_length = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_airflow_gain_fade_length', None) @property def has_field_last_frame_speed_in_air_rtpc_key(self): if hasattr(self, '_m_has_field_last_frame_speed_in_air_rtpc_key'): return self._m_has_field_last_frame_speed_in_air_rtpc_key self._m_has_field_last_frame_speed_in_air_rtpc_key = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_last_frame_speed_in_air_rtpc_key', None) class FishingEventComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMpPlayerSettleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MpPlayerSettleType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigSpatialRoomLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSpatialRoom(self._io, self, self._root)) class ArrayOfVectorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.Vector(self._io, self, self._root)) class DictOfAuxTypesStringFaceAnimationTypeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringFaceAnimationTypeConfig(self._io, self, self._root)) class EnumCheckHitLayerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CheckHitLayerType, self.data.value) return getattr(self, '_m_value', None) class NativeAllocatorEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TemplateParamFloat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TemplateParam(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_origin_value: self.origin_value = self._io.read_f4le() @property def has_field_origin_value(self): if hasattr(self, '_m_has_field_origin_value'): return self._m_has_field_origin_value self._m_has_field_origin_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_origin_value', None) @property def param(self): if hasattr(self, '_m_param'): return self._m_param self._m_param = self.base.param return getattr(self, '_m_param', None) class EnumExhibitionKeyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionKeyType, self.data.value) return getattr(self, '_m_value', None) class ConfigBattleFervorFactor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_factor_min_value: self.factor_min_value = self._io.read_f4le() if self.has_field_factor_max_value: self.factor_max_value = self._io.read_f4le() if self.has_field_factor_init_value: self.factor_init_value = self._io.read_f4le() @property def has_field_factor_min_value(self): if hasattr(self, '_m_has_field_factor_min_value'): return self._m_has_field_factor_min_value self._m_has_field_factor_min_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_factor_min_value', None) @property def has_field_factor_max_value(self): if hasattr(self, '_m_has_field_factor_max_value'): return self._m_has_field_factor_max_value self._m_has_field_factor_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_factor_max_value', None) @property def has_field_factor_init_value(self): if hasattr(self, '_m_has_field_factor_init_value'): return self._m_has_field_factor_init_value self._m_has_field_factor_init_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_factor_init_value', None) class KvpOfDictAuxTypesStringConfigPerfStringKeyItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfStringKeyItem(self._io, self, self._root) class CrystalLinkDifficultyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityOverrideExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGroupRecordType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GroupRecordType, self.data.value) return getattr(self, '_m_value', None) class DungeonExit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_entry_point_id: self.entry_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_entry_point_id(self): if hasattr(self, '_m_has_field_entry_point_id'): return self._m_has_field_entry_point_id self._m_has_field_entry_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_entry_point_id', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class EnumFireworksType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FireworksType, self.data.value) return getattr(self, '_m_value', None) class HideAndSeekMatchExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MarkType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigQteStepCondActionGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigQteStepCondActionGroup(self._io, self, self._root)) class ConfigAudioSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_volume: self.global_volume = Output.AudioSettingSliderPostEvent(self._io, self, self._root) if self.has_field_sfx_volume: self.sfx_volume = Output.AudioSettingSliderPostEvent(self._io, self, self._root) if self.has_field_music_volume: self.music_volume = Output.AudioSettingSliderPostEvent(self._io, self, self._root) if self.has_field_voice_volume: self.voice_volume = Output.AudioSettingSliderPostVoice(self._io, self, self._root) if self.has_field_vibration: self.vibration = Output.VibrationSetting(self._io, self, self._root) if self.has_field_dual_sense_rtpc: self.dual_sense_rtpc = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_dynamic_range_rtpc_key: self.dynamic_range_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_output_setting_map: self.output_setting_map = Output.DictOfAuxTypesVlqBase128LeSOutputSetting(self._io, self, self._root) if self.has_field_platform_settings: self.platform_settings = Output.DictOfAuxTypesStringAudioPlatformSetting(self._io, self, self._root) @property def has_field_sfx_volume(self): if hasattr(self, '_m_has_field_sfx_volume'): return self._m_has_field_sfx_volume self._m_has_field_sfx_volume = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_sfx_volume', None) @property def has_field_voice_volume(self): if hasattr(self, '_m_has_field_voice_volume'): return self._m_has_field_voice_volume self._m_has_field_voice_volume = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_voice_volume', None) @property def has_field_music_volume(self): if hasattr(self, '_m_has_field_music_volume'): return self._m_has_field_music_volume self._m_has_field_music_volume = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_music_volume', None) @property def has_field_dynamic_range_rtpc_key(self): if hasattr(self, '_m_has_field_dynamic_range_rtpc_key'): return self._m_has_field_dynamic_range_rtpc_key self._m_has_field_dynamic_range_rtpc_key = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_dynamic_range_rtpc_key', None) @property def has_field_global_volume(self): if hasattr(self, '_m_has_field_global_volume'): return self._m_has_field_global_volume self._m_has_field_global_volume = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_global_volume', None) @property def has_field_dual_sense_rtpc(self): if hasattr(self, '_m_has_field_dual_sense_rtpc'): return self._m_has_field_dual_sense_rtpc self._m_has_field_dual_sense_rtpc = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_dual_sense_rtpc', None) @property def has_field_platform_settings(self): if hasattr(self, '_m_has_field_platform_settings'): return self._m_has_field_platform_settings self._m_has_field_platform_settings = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_platform_settings', None) @property def has_field_output_setting_map(self): if hasattr(self, '_m_has_field_output_setting_map'): return self._m_has_field_output_setting_map self._m_has_field_output_setting_map = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_output_setting_map', None) @property def has_field_vibration(self): if hasattr(self, '_m_has_field_vibration'): return self._m_has_field_vibration self._m_has_field_vibration = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_vibration', None) class RewardPreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.String(self._io, self, self._root) if self.has_field_preview_items: self.preview_items = Output.ArrayOfIdCountStrConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_preview_items(self): if hasattr(self, '_m_has_field_preview_items'): return self._m_has_field_preview_items self._m_has_field_preview_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_preview_items', None) class EnumQteStepCameraTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepCameraTargetType, self.data.value) return getattr(self, '_m_value', None) class ReminderStyleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNpcBornPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_id: self.room_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suite_id: self.suite_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suite_id_list: self.suite_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_suite_id_list(self): if hasattr(self, '_m_has_field_suite_id_list'): return self._m_has_field_suite_id_list self._m_has_field_suite_id_list = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_suite_id_list', None) @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_rot', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_group_id', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_room_id(self): if hasattr(self, '_m_has_field_room_id'): return self._m_has_field_room_id self._m_has_field_room_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_room_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_suite_id(self): if hasattr(self, '_m_has_field_suite_id'): return self._m_has_field_suite_id self._m_has_field_suite_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_suite_id', None) class NewActivityScoreShowExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRuleWaitDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() if self.has_field_recheck_frame: self.recheck_frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) @property def has_field_recheck_frame(self): if hasattr(self, '_m_has_field_recheck_frame'): return self._m_has_field_recheck_frame self._m_has_field_recheck_frame = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_recheck_frame', None) class ActivityGroupLinkPlayTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumIrodoriChessCardQualityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardQualityType, self.data.value) return getattr(self, '_m_value', None) class EnumOpActivityBonusSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpActivityBonusSourceType, self.data.value) return getattr(self, '_m_value', None) class DailyTaskRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GachaItemParentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestGuideNpcSelectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestGuideNpcSelectType, self.data.value) return getattr(self, '_m_value', None) class ConfigDirectionByRefraction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_valid_angle_range: self.valid_angle_range = self._io.read_f4le() @property def has_field_valid_angle_range(self): if hasattr(self, '_m_has_field_valid_angle_range'): return self._m_has_field_valid_angle_range self._m_has_field_valid_angle_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_valid_angle_range', None) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class UgcTimeControlTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReunionScheduleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activate_level: self.activate_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_first_gift_reward_id: self.first_gift_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_sign_in_id: self.daily_sign_in_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reunion_mission_id: self.reunion_mission_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reunion_privilege_id: self.reunion_privilege_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_first_gift_reward_id(self): if hasattr(self, '_m_has_field_first_gift_reward_id'): return self._m_has_field_first_gift_reward_id self._m_has_field_first_gift_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_first_gift_reward_id', None) @property def has_field_activate_level(self): if hasattr(self, '_m_has_field_activate_level'): return self._m_has_field_activate_level self._m_has_field_activate_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activate_level', None) @property def has_field_reunion_privilege_id(self): if hasattr(self, '_m_has_field_reunion_privilege_id'): return self._m_has_field_reunion_privilege_id self._m_has_field_reunion_privilege_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reunion_privilege_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_daily_sign_in_id(self): if hasattr(self, '_m_has_field_daily_sign_in_id'): return self._m_has_field_daily_sign_in_id self._m_has_field_daily_sign_in_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_daily_sign_in_id', None) @property def has_field_reunion_mission_id(self): if hasattr(self, '_m_has_field_reunion_mission_id'): return self._m_has_field_reunion_mission_id self._m_has_field_reunion_mission_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reunion_mission_id', None) class KvpOfDictAuxTypesStringAuxTypesVlqBase128LeU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) class EnumOpenStateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpenStateType, self.data.value) return getattr(self, '_m_value', None) class AttachPointTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPerfGradeItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfGradeItemOverrideInfo(self._io, self, self._root) class RogueDiaryDungeonExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_list: self.group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_round_list: self.round_list = Output.ArrayOfRogueDiaryRoundExcelConfigLengthS(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_group_list(self): if hasattr(self, '_m_has_field_group_list'): return self._m_has_field_group_list self._m_has_field_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_list', None) @property def has_field_round_list(self): if hasattr(self, '_m_has_field_round_list'): return self._m_has_field_round_list self._m_has_field_round_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_round_list', None) class KvpOfDictAuxTypesVlqBase128LeSConfigCutsceneContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigCutsceneContext(self._io, self, self._root) class SetEntityScale(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scale: self.scale = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scale', None) class ContextActionSetAnimatorTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_element: self.ui_element = Output.EnumActivityBannerUiElementType(self._io, self, self._root) if self.has_field_trigger_name: self.trigger_name = AuxTypes.String(self._io, self, self._root) if self.has_field_set_or_reset: self.set_or_reset = self._io.read_u1() @property def has_field_ui_element(self): if hasattr(self, '_m_has_field_ui_element'): return self._m_has_field_ui_element self._m_has_field_ui_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_element', None) @property def has_field_trigger_name(self): if hasattr(self, '_m_has_field_trigger_name'): return self._m_has_field_trigger_name self._m_has_field_trigger_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trigger_name', None) @property def has_field_set_or_reset(self): if hasattr(self, '_m_has_field_set_or_reset'): return self._m_has_field_set_or_reset self._m_has_field_set_or_reset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_or_reset', None) class EnumAvatarFashionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AvatarFashionType, self.data.value) return getattr(self, '_m_value', None) class UshortIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMatchLimitType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MatchLimitType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigHomeworldBlockDefaultSaveLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldBlockDefaultSave(self._io, self, self._root)) class QuestCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumExclusivePlatformType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExclusivePlatformType, self.data.value) return getattr(self, '_m_value', None) class EnumBrickRotateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BrickRotateType, self.data.value) return getattr(self, '_m_value', None) class ConfigGlobalMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sync_interval: self.sync_interval = Output.ConfigMoveSyncInterval(self._io, self, self._root) if self.has_field_no_ground_stay_in_place: self.no_ground_stay_in_place = self._io.read_u1() @property def has_field_sync_interval(self): if hasattr(self, '_m_has_field_sync_interval'): return self._m_has_field_sync_interval self._m_has_field_sync_interval = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sync_interval', None) @property def has_field_no_ground_stay_in_place(self): if hasattr(self, '_m_has_field_no_ground_stay_in_place'): return self._m_has_field_no_ground_stay_in_place self._m_has_field_no_ground_stay_in_place = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_no_ground_stay_in_place', None) class DamageClampTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RecordActorTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SkinColor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_renderer: self.renderer = AuxTypes.String(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_channel: self.channel = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_color: self.color = AuxTypes.String(self._io, self, self._root) @property def has_field_renderer(self): if hasattr(self, '_m_has_field_renderer'): return self._m_has_field_renderer self._m_has_field_renderer = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_renderer', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_index', None) @property def has_field_channel(self): if hasattr(self, '_m_has_field_channel'): return self._m_has_field_channel self._m_has_field_channel = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_channel', None) @property def has_field_color(self): if hasattr(self, '_m_has_field_color'): return self._m_has_field_color self._m_has_field_color = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_color', None) class Uint16NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class MpPlayMatchExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_type: self.play_type = Output.EnumMpPlayType(self._io, self, self._root) if self.has_field_play_name: self.play_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_play_desc: self.play_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_auto_match: self.is_auto_match = self._io.read_u1() if self.has_field_min_players: self.min_players = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_players: self.max_players = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_allow_in_any_time: self.is_allow_in_any_time = self._io.read_u1() if self.has_field_is_match_necessary: self.is_match_necessary = self._io.read_u1() if self.has_field_settle_type: self.settle_type = Output.EnumMpPlaySettleType(self._io, self, self._root) if self.has_field_series_id: self.series_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_list: self.buff_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bg_image: self.bg_image = AuxTypes.String(self._io, self, self._root) if self.has_field_no_progress: self.no_progress = self._io.read_u1() @property def has_field_bg_image(self): if hasattr(self, '_m_has_field_bg_image'): return self._m_has_field_bg_image self._m_has_field_bg_image = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_bg_image', None) @property def has_field_no_progress(self): if hasattr(self, '_m_has_field_no_progress'): return self._m_has_field_no_progress self._m_has_field_no_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_no_progress', None) @property def has_field_is_match_necessary(self): if hasattr(self, '_m_has_field_is_match_necessary'): return self._m_has_field_is_match_necessary self._m_has_field_is_match_necessary = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_match_necessary', None) @property def has_field_min_players(self): if hasattr(self, '_m_has_field_min_players'): return self._m_has_field_min_players self._m_has_field_min_players = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_min_players', None) @property def has_field_is_allow_in_any_time(self): if hasattr(self, '_m_has_field_is_allow_in_any_time'): return self._m_has_field_is_allow_in_any_time self._m_has_field_is_allow_in_any_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_allow_in_any_time', None) @property def has_field_play_name(self): if hasattr(self, '_m_has_field_play_name'): return self._m_has_field_play_name self._m_has_field_play_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_play_name', None) @property def has_field_max_players(self): if hasattr(self, '_m_has_field_max_players'): return self._m_has_field_max_players self._m_has_field_max_players = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_max_players', None) @property def has_field_buff_list(self): if hasattr(self, '_m_has_field_buff_list'): return self._m_has_field_buff_list self._m_has_field_buff_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_buff_list', None) @property def has_field_is_auto_match(self): if hasattr(self, '_m_has_field_is_auto_match'): return self._m_has_field_is_auto_match self._m_has_field_is_auto_match = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_auto_match', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_play_type', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_settle_type(self): if hasattr(self, '_m_has_field_settle_type'): return self._m_has_field_settle_type self._m_has_field_settle_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_settle_type', None) @property def has_field_play_desc(self): if hasattr(self, '_m_has_field_play_desc'): return self._m_has_field_play_desc self._m_has_field_play_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_play_desc', None) @property def has_field_series_id(self): if hasattr(self, '_m_has_field_series_id'): return self._m_has_field_series_id self._m_has_field_series_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_series_id', None) class ConfigGuideActivityGachaCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_percent: self.percent = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_opt: self.opt = Output.EnumGuideOperator(self._io, self, self._root) @property def has_field_percent(self): if hasattr(self, '_m_has_field_percent'): return self._m_has_field_percent self._m_has_field_percent = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_percent', None) @property def has_field_opt(self): if hasattr(self, '_m_has_field_opt'): return self._m_has_field_opt self._m_has_field_opt = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_opt', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class EnumEquipInSlotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EquipInSlotType, self.data.value) return getattr(self, '_m_value', None) class NewActivityOverlapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumInvolveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InvolveType, self.data.value) return getattr(self, '_m_value', None) class ChallengeCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDraftExecType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DraftExecType, self.data.value) return getattr(self, '_m_value', None) class ConfigTimeSlow(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_slow_ratio: self.slow_ratio = self._io.read_f4le() @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_slow_ratio(self): if hasattr(self, '_m_has_field_slow_ratio'): return self._m_has_field_slow_ratio self._m_has_field_slow_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_slow_ratio', None) class ConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_text: self.text = AuxTypes.String(self._io, self, self._root) @property def has_field_text(self): if hasattr(self, '_m_has_field_text'): return self._m_has_field_text self._m_has_field_text = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_text', None) class ArrayOfQuestCondExLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestCondEx(self._io, self, self._root)) class CoopRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_cond: self.reward_cond = Output.ArrayOfCoopCondConfigLengthS(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_tip: self.cond_tip = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_tip_des: self.cond_tip_des = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sort_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_cond_tip(self): if hasattr(self, '_m_has_field_cond_tip'): return self._m_has_field_cond_tip self._m_has_field_cond_tip = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cond_tip', None) @property def has_field_cond_tip_des(self): if hasattr(self, '_m_has_field_cond_tip_des'): return self._m_has_field_cond_tip_des self._m_has_field_cond_tip_des = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cond_tip_des', None) @property def has_field_reward_cond(self): if hasattr(self, '_m_has_field_reward_cond'): return self._m_has_field_reward_cond self._m_has_field_reward_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_cond', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_id', None) class ConfigAiCombatFixedMoveSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiCombatFixedMoveData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiCombatFixedMoveData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigAiFishingFleeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFishingFleeData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFishingFleeData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigGuideMultiPlayerCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_in: self.is_in = self._io.read_u1() if self.has_field_player_num: self.player_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_opt: self.opt = Output.EnumGuideOperator(self._io, self, self._root) if self.has_field_mode: self.mode = Output.EnumGuideMultiPlayerMode(self._io, self, self._root) @property def has_field_is_in(self): if hasattr(self, '_m_has_field_is_in'): return self._m_has_field_is_in self._m_has_field_is_in = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_in', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_mode(self): if hasattr(self, '_m_has_field_mode'): return self._m_has_field_mode self._m_has_field_mode = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_mode', None) @property def has_field_player_num(self): if hasattr(self, '_m_has_field_player_num'): return self._m_has_field_player_num self._m_has_field_player_num = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_player_num', None) @property def has_field_opt(self): if hasattr(self, '_m_has_field_opt'): return self._m_has_field_opt self._m_has_field_opt = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_opt', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class EnumProudLifeEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProudLifeEffectType, self.data.value) return getattr(self, '_m_value', None) class EnumTileSpecialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TileSpecialType, self.data.value) return getattr(self, '_m_value', None) class EnumConfigGuideContextListType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigGuideContextListType, self.data.value) return getattr(self, '_m_value', None) class PushDvalinS01process(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_to_percentage: self.to_percentage = self._io.read_f4le() if self.has_field_un_break: self.un_break = self._io.read_u1() if self.has_field_set_force: self.set_force = self._io.read_u1() if self.has_field_vector: self.vector = Output.Vector(self._io, self, self._root) if self.has_field_attenuation: self.attenuation = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_force(self): if hasattr(self, '_m_has_field_set_force'): return self._m_has_field_set_force self._m_has_field_set_force = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_set_force', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def has_field_vector(self): if hasattr(self, '_m_has_field_vector'): return self._m_has_field_vector self._m_has_field_vector = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_vector', None) @property def has_field_un_break(self): if hasattr(self, '_m_has_field_un_break'): return self._m_has_field_un_break self._m_has_field_un_break = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_un_break', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_to_percentage(self): if hasattr(self, '_m_has_field_to_percentage'): return self._m_has_field_to_percentage self._m_has_field_to_percentage = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_percentage', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time', None) class OraionokamiDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IdCountStrConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_count', None) class MoonfinTrialLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_type: self.level_type = Output.EnumMoonfinTrialActivityLevelType(self._io, self, self._root) if self.has_field_specific_fish_id: self.specific_fish_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_leading_level: self.leading_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_leading_main_quest: self.leading_main_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest: self.main_quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_position: self.mark_position = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_name: self.level_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_description: self.description = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_specific_fish_id(self): if hasattr(self, '_m_has_field_specific_fish_id'): return self._m_has_field_specific_fish_id self._m_has_field_specific_fish_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_specific_fish_id', None) @property def has_field_level_type(self): if hasattr(self, '_m_has_field_level_type'): return self._m_has_field_level_type self._m_has_field_level_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_type', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_level_name(self): if hasattr(self, '_m_has_field_level_name'): return self._m_has_field_level_name self._m_has_field_level_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_level_name', None) @property def has_field_description(self): if hasattr(self, '_m_has_field_description'): return self._m_has_field_description self._m_has_field_description = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_description', None) @property def has_field_main_quest(self): if hasattr(self, '_m_has_field_main_quest'): return self._m_has_field_main_quest self._m_has_field_main_quest = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_main_quest', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_challenge_id', None) @property def has_field_leading_level(self): if hasattr(self, '_m_has_field_leading_level'): return self._m_has_field_leading_level self._m_has_field_leading_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_leading_level', None) @property def has_field_leading_main_quest(self): if hasattr(self, '_m_has_field_leading_main_quest'): return self._m_has_field_leading_main_quest self._m_has_field_leading_main_quest = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_leading_main_quest', None) @property def has_field_mark_position(self): if hasattr(self, '_m_has_field_mark_position'): return self._m_has_field_mark_position self._m_has_field_mark_position = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_mark_position', None) class ConfigMusicInt32condition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigAvatarStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigNormalStateIdInfo(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camera_type: self.camera_type = Output.EnumStateCameraType(self._io, self, self._root) if self.has_field_camera_param: self.camera_param = Output.ConfigStateCameraParam(self._io, self, self._root) if self.has_field_can_change_avatar: self.can_change_avatar = Output.ArrayOfConfigCanChangeAvatarLengthU(self._io, self, self._root) if self.has_field_can_support_change: self.can_support_change = self._io.read_u1() if self.has_field_action_panel_state: self.action_panel_state = Output.EnumActionPanelState(self._io, self, self._root) if self.has_field_equip_reattach: self.equip_reattach = Output.ArrayOfConfigEquipReattachLengthU(self._io, self, self._root) if self.has_field_jump_cancel_start: self.jump_cancel_start = self._io.read_f4le() if self.has_field_jump_cancel_end: self.jump_cancel_end = self._io.read_f4le() if self.has_field_sprint_cancel_start: self.sprint_cancel_start = self._io.read_f4le() if self.has_field_sprint_cancel_end: self.sprint_cancel_end = self._io.read_f4le() if self.has_field_fly_cancel_start: self.fly_cancel_start = self._io.read_f4le() if self.has_field_fly_cancel_end: self.fly_cancel_end = self._io.read_f4le() if self.has_field_animator_trigger_on_landed: self.animator_trigger_on_landed = AuxTypes.String(self._io, self, self._root) if self.has_field_battou_on_start: self.battou_on_start = self._io.read_u1() if self.has_field_sheathe_on_start: self.sheathe_on_start = self._io.read_u1() if self.has_field_sheathe_on_end: self.sheathe_on_end = self._io.read_u1() if self.has_field_ignore_pre_sheath: self.ignore_pre_sheath = self._io.read_u1() if self.has_field_sub_equip_config: self.sub_equip_config = self._io.read_u1() @property def has_field_fly_cancel_end(self): if hasattr(self, '_m_has_field_fly_cancel_end'): return self._m_has_field_fly_cancel_end self._m_has_field_fly_cancel_end = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_fly_cancel_end', None) @property def set_animator_float(self): if hasattr(self, '_m_set_animator_float'): return self._m_set_animator_float self._m_set_animator_float = self.base.set_animator_float return getattr(self, '_m_set_animator_float', None) @property def can_do_skill(self): if hasattr(self, '_m_can_do_skill'): return self._m_can_do_skill self._m_can_do_skill = self.base.can_do_skill return getattr(self, '_m_can_do_skill', None) @property def has_field_equip_reattach(self): if hasattr(self, '_m_has_field_equip_reattach'): return self._m_has_field_equip_reattach self._m_has_field_equip_reattach = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_equip_reattach', None) @property def has_field_fly_cancel_start(self): if hasattr(self, '_m_has_field_fly_cancel_start'): return self._m_has_field_fly_cancel_start self._m_has_field_fly_cancel_start = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_fly_cancel_start', None) @property def enable_ccd(self): if hasattr(self, '_m_enable_ccd'): return self._m_enable_ccd self._m_enable_ccd = self.base.enable_ccd return getattr(self, '_m_enable_ccd', None) @property def culling_model_always_animate(self): if hasattr(self, '_m_culling_model_always_animate'): return self._m_culling_model_always_animate self._m_culling_model_always_animate = self.base.culling_model_always_animate return getattr(self, '_m_culling_model_always_animate', None) @property def add_endure(self): if hasattr(self, '_m_add_endure'): return self._m_add_endure self._m_add_endure = self.base.add_endure return getattr(self, '_m_add_endure', None) @property def has_field_sprint_cancel_start(self): if hasattr(self, '_m_has_field_sprint_cancel_start'): return self._m_has_field_sprint_cancel_start self._m_has_field_sprint_cancel_start = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_sprint_cancel_start', None) @property def reset_animator_trigger_on_exit(self): if hasattr(self, '_m_reset_animator_trigger_on_exit'): return self._m_reset_animator_trigger_on_exit self._m_reset_animator_trigger_on_exit = self.base.reset_animator_trigger_on_exit return getattr(self, '_m_reset_animator_trigger_on_exit', None) @property def mass_ratio(self): if hasattr(self, '_m_mass_ratio'): return self._m_mass_ratio self._m_mass_ratio = self.base.mass_ratio return getattr(self, '_m_mass_ratio', None) @property def animator_states(self): if hasattr(self, '_m_animator_states'): return self._m_animator_states self._m_animator_states = self.base.animator_states return getattr(self, '_m_animator_states', None) @property def has_field_camera_type(self): if hasattr(self, '_m_has_field_camera_type'): return self._m_has_field_camera_type self._m_has_field_camera_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_camera_type', None) @property def combat_move_on_water(self): if hasattr(self, '_m_combat_move_on_water'): return self._m_combat_move_on_water self._m_combat_move_on_water = self.base.combat_move_on_water return getattr(self, '_m_combat_move_on_water', None) @property def set_animator_boolean(self): if hasattr(self, '_m_set_animator_boolean'): return self._m_set_animator_boolean self._m_set_animator_boolean = self.base.set_animator_boolean return getattr(self, '_m_set_animator_boolean', None) @property def has_field_battou_on_start(self): if hasattr(self, '_m_has_field_battou_on_start'): return self._m_has_field_battou_on_start self._m_has_field_battou_on_start = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_battou_on_start', None) @property def handle_animator_state_immediately(self): if hasattr(self, '_m_handle_animator_state_immediately'): return self._m_handle_animator_state_immediately self._m_handle_animator_state_immediately = self.base.handle_animator_state_immediately return getattr(self, '_m_handle_animator_state_immediately', None) @property def has_field_sheathe_on_start(self): if hasattr(self, '_m_has_field_sheathe_on_start'): return self._m_has_field_sheathe_on_start self._m_has_field_sheathe_on_start = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_sheathe_on_start', None) @property def has_field_action_panel_state(self): if hasattr(self, '_m_has_field_action_panel_state'): return self._m_has_field_action_panel_state self._m_has_field_action_panel_state = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_action_panel_state', None) @property def has_field_can_change_avatar(self): if hasattr(self, '_m_has_field_can_change_avatar'): return self._m_has_field_can_change_avatar self._m_has_field_can_change_avatar = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_can_change_avatar', None) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def has_field_camera_param(self): if hasattr(self, '_m_has_field_camera_param'): return self._m_has_field_camera_param self._m_has_field_camera_param = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_camera_param', None) @property def can_do_skill_start(self): if hasattr(self, '_m_can_do_skill_start'): return self._m_can_do_skill_start self._m_can_do_skill_start = self.base.can_do_skill_start return getattr(self, '_m_can_do_skill_start', None) @property def has_field_jump_cancel_end(self): if hasattr(self, '_m_has_field_jump_cancel_end'): return self._m_has_field_jump_cancel_end self._m_has_field_jump_cancel_end = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_jump_cancel_end', None) @property def has_field_sub_equip_config(self): if hasattr(self, '_m_has_field_sub_equip_config'): return self._m_has_field_sub_equip_config self._m_has_field_sub_equip_config = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_sub_equip_config', None) @property def has_field_sprint_cancel_end(self): if hasattr(self, '_m_has_field_sprint_cancel_end'): return self._m_has_field_sprint_cancel_end self._m_has_field_sprint_cancel_end = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_sprint_cancel_end', None) @property def has_field_ignore_pre_sheath(self): if hasattr(self, '_m_has_field_ignore_pre_sheath'): return self._m_has_field_ignore_pre_sheath self._m_has_field_ignore_pre_sheath = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_ignore_pre_sheath', None) @property def has_field_jump_cancel_start(self): if hasattr(self, '_m_has_field_jump_cancel_start'): return self._m_has_field_jump_cancel_start self._m_has_field_jump_cancel_start = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_jump_cancel_start', None) @property def can_sync_move(self): if hasattr(self, '_m_can_sync_move'): return self._m_can_sync_move self._m_can_sync_move = self.base.can_sync_move return getattr(self, '_m_can_sync_move', None) @property def has_field_animator_trigger_on_landed(self): if hasattr(self, '_m_has_field_animator_trigger_on_landed'): return self._m_has_field_animator_trigger_on_landed self._m_has_field_animator_trigger_on_landed = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_animator_trigger_on_landed', None) @property def reset_animator_trigger_on_enter(self): if hasattr(self, '_m_reset_animator_trigger_on_enter'): return self._m_reset_animator_trigger_on_enter self._m_reset_animator_trigger_on_enter = self.base.reset_animator_trigger_on_enter return getattr(self, '_m_reset_animator_trigger_on_enter', None) @property def has_field_can_support_change(self): if hasattr(self, '_m_has_field_can_support_change'): return self._m_has_field_can_support_change self._m_has_field_can_support_change = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_can_support_change', None) @property def can_do_skill_end(self): if hasattr(self, '_m_can_do_skill_end'): return self._m_can_do_skill_end self._m_can_do_skill_end = self.base.can_do_skill_end return getattr(self, '_m_can_do_skill_end', None) @property def move_type(self): if hasattr(self, '_m_move_type'): return self._m_move_type self._m_move_type = self.base.move_type return getattr(self, '_m_move_type', None) @property def need_face_to_anim_param(self): if hasattr(self, '_m_need_face_to_anim_param'): return self._m_need_face_to_anim_param self._m_need_face_to_anim_param = self.base.need_face_to_anim_param return getattr(self, '_m_need_face_to_anim_param', None) @property def has_field_sheathe_on_end(self): if hasattr(self, '_m_has_field_sheathe_on_end'): return self._m_has_field_sheathe_on_end self._m_has_field_sheathe_on_end = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_sheathe_on_end', None) @property def enable_rag_doll(self): if hasattr(self, '_m_enable_rag_doll'): return self._m_enable_rag_doll self._m_enable_rag_doll = self.base.enable_rag_doll return getattr(self, '_m_enable_rag_doll', None) class HomeworldAnimalExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class OverrideAttackEventMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_override_attack_event: self.override_attack_event = AuxTypes.String(self._io, self, self._root) @property def has_field_override_attack_event(self): if hasattr(self, '_m_has_field_override_attack_event'): return self._m_has_field_override_attack_event self._m_has_field_override_attack_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_override_attack_event', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WidgetGeneralExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_can_use_in_other_world: self.can_use_in_other_world = self._io.read_u1() if self.has_field_can_use_in_room: self.can_use_in_room = self._io.read_u1() if self.has_field_forbidden_scene_id_list: self.forbidden_scene_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_can_use_when_current_avatar_dead: self.can_use_when_current_avatar_dead = self._io.read_u1() if self.has_field_can_use_in_limit_region: self.can_use_in_limit_region = self._io.read_u1() if self.has_field_can_use_when_fight: self.can_use_when_fight = self._io.read_u1() if self.has_field_can_use_in_un_normal_move_state: self.can_use_in_un_normal_move_state = self._io.read_u1() if self.has_field_can_use_in_avatar_focus: self.can_use_in_avatar_focus = self._io.read_u1() if self.has_field_can_use_in_dungeon: self.can_use_in_dungeon = self._io.read_u1() if self.has_field_can_use_in_tower: self.can_use_in_tower = self._io.read_u1() if self.has_field_can_use_in_homeworld: self.can_use_in_homeworld = self._io.read_u1() if self.has_field_vehicle_limit: self.vehicle_limit = Output.EnumVehicleLimitType(self._io, self, self._root) if self.has_field_forbidden_dungeon_type_list: self.forbidden_dungeon_type_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_forbidden_dungeon_play_type_list: self.forbidden_dungeon_play_type_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_can_use_when_fight(self): if hasattr(self, '_m_has_field_can_use_when_fight'): return self._m_has_field_can_use_when_fight self._m_has_field_can_use_when_fight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_can_use_when_fight', None) @property def has_field_vehicle_limit(self): if hasattr(self, '_m_has_field_vehicle_limit'): return self._m_has_field_vehicle_limit self._m_has_field_vehicle_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_vehicle_limit', None) @property def has_field_can_use_in_avatar_focus(self): if hasattr(self, '_m_has_field_can_use_in_avatar_focus'): return self._m_has_field_can_use_in_avatar_focus self._m_has_field_can_use_in_avatar_focus = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_can_use_in_avatar_focus', None) @property def has_field_forbidden_scene_id_list(self): if hasattr(self, '_m_has_field_forbidden_scene_id_list'): return self._m_has_field_forbidden_scene_id_list self._m_has_field_forbidden_scene_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_forbidden_scene_id_list', None) @property def has_field_can_use_in_dungeon(self): if hasattr(self, '_m_has_field_can_use_in_dungeon'): return self._m_has_field_can_use_in_dungeon self._m_has_field_can_use_in_dungeon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_can_use_in_dungeon', None) @property def has_field_can_use_in_un_normal_move_state(self): if hasattr(self, '_m_has_field_can_use_in_un_normal_move_state'): return self._m_has_field_can_use_in_un_normal_move_state self._m_has_field_can_use_in_un_normal_move_state = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_can_use_in_un_normal_move_state', None) @property def has_field_can_use_in_room(self): if hasattr(self, '_m_has_field_can_use_in_room'): return self._m_has_field_can_use_in_room self._m_has_field_can_use_in_room = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_can_use_in_room', None) @property def has_field_can_use_when_current_avatar_dead(self): if hasattr(self, '_m_has_field_can_use_when_current_avatar_dead'): return self._m_has_field_can_use_when_current_avatar_dead self._m_has_field_can_use_when_current_avatar_dead = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_can_use_when_current_avatar_dead', None) @property def has_field_can_use_in_limit_region(self): if hasattr(self, '_m_has_field_can_use_in_limit_region'): return self._m_has_field_can_use_in_limit_region self._m_has_field_can_use_in_limit_region = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_can_use_in_limit_region', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_can_use_in_homeworld(self): if hasattr(self, '_m_has_field_can_use_in_homeworld'): return self._m_has_field_can_use_in_homeworld self._m_has_field_can_use_in_homeworld = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_can_use_in_homeworld', None) @property def has_field_can_use_in_tower(self): if hasattr(self, '_m_has_field_can_use_in_tower'): return self._m_has_field_can_use_in_tower self._m_has_field_can_use_in_tower = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_can_use_in_tower', None) @property def has_field_can_use_in_other_world(self): if hasattr(self, '_m_has_field_can_use_in_other_world'): return self._m_has_field_can_use_in_other_world self._m_has_field_can_use_in_other_world = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_can_use_in_other_world', None) @property def has_field_forbidden_dungeon_play_type_list(self): if hasattr(self, '_m_has_field_forbidden_dungeon_play_type_list'): return self._m_has_field_forbidden_dungeon_play_type_list self._m_has_field_forbidden_dungeon_play_type_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_forbidden_dungeon_play_type_list', None) @property def has_field_forbidden_dungeon_type_list(self): if hasattr(self, '_m_has_field_forbidden_dungeon_type_list'): return self._m_has_field_forbidden_dungeon_type_list self._m_has_field_forbidden_dungeon_type_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_forbidden_dungeon_type_list', None) class ConfigGadgetStateFireEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGadgetStateAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_root_name: self.root_name = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.String(self._io, self, self._root) @property def has_field_root_name(self): if hasattr(self, '_m_has_field_root_name'): return self._m_has_field_root_name self._m_has_field_root_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_root_name', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def gadget_state(self): if hasattr(self, '_m_gadget_state'): return self._m_gadget_state self._m_gadget_state = self.base.gadget_state return getattr(self, '_m_gadget_state', None) @property def predicate(self): if hasattr(self, '_m_predicate'): return self._m_predicate self._m_predicate = self.base.predicate return getattr(self, '_m_predicate', None) class OpResponderComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumLevelDayTimeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LevelDayTimeType, self.data.value) return getattr(self, '_m_value', None) class SetPoseBool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_bool_id: self.bool_id = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_u1() @property def has_field_bool_id(self): if hasattr(self, '_m_has_field_bool_id'): return self._m_has_field_bool_id self._m_has_field_bool_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bool_id', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ForgeUpdateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_player_level: self.player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_forge_queue_num: self.forge_queue_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_player_level(self): if hasattr(self, '_m_has_field_player_level'): return self._m_has_field_player_level self._m_has_field_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_player_level', None) @property def has_field_forge_queue_num(self): if hasattr(self, '_m_has_field_forge_queue_num'): return self._m_has_field_forge_queue_num self._m_has_field_forge_queue_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_forge_queue_num', None) class CardProductTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RegionSearchExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_name: self.search_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_desc: self.search_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_search_complete: self.search_complete = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_icon_type_name: self.mark_icon_type_name = AuxTypes.String(self._io, self, self._root) if self.has_field_search_type: self.search_type = Output.EnumRegionSearchType(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_clear_material: self.is_clear_material = self._io.read_u1() if self.has_field_search_group_id: self.search_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group: self.ability_group = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_group(self): if hasattr(self, '_m_has_field_ability_group'): return self._m_has_field_ability_group self._m_has_field_ability_group = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_ability_group', None) @property def has_field_is_clear_material(self): if hasattr(self, '_m_has_field_is_clear_material'): return self._m_has_field_is_clear_material self._m_has_field_is_clear_material = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_clear_material', None) @property def has_field_search_group_id(self): if hasattr(self, '_m_has_field_search_group_id'): return self._m_has_field_search_group_id self._m_has_field_search_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_search_group_id', None) @property def has_field_search_desc(self): if hasattr(self, '_m_has_field_search_desc'): return self._m_has_field_search_desc self._m_has_field_search_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_search_desc', None) @property def has_field_search_complete(self): if hasattr(self, '_m_has_field_search_complete'): return self._m_has_field_search_complete self._m_has_field_search_complete = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_search_complete', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_search_type(self): if hasattr(self, '_m_has_field_search_type'): return self._m_has_field_search_type self._m_has_field_search_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_search_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_search_name(self): if hasattr(self, '_m_has_field_search_name'): return self._m_has_field_search_name self._m_has_field_search_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_search_name', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_revise_level', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) @property def has_field_mark_icon_type_name(self): if hasattr(self, '_m_has_field_mark_icon_type_name'): return self._m_has_field_mark_icon_type_name self._m_has_field_mark_icon_type_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_mark_icon_type_name', None) class ConfigEntityPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_absorb: self.element_absorb = AuxTypes.String(self._io, self, self._root) if self.has_field_element_pendant: self.element_pendant = AuxTypes.String(self._io, self, self._root) if self.has_field_element_drop: self.element_drop = AuxTypes.String(self._io, self, self._root) if self.has_field_bullet_aim: self.bullet_aim = AuxTypes.String(self._io, self, self._root) if self.has_field_hit_points: self.hit_points = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_selected_points: self.selected_points = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ignore_transform: self.ignore_transform = self._io.read_u1() if self.has_field_selected_point_radius: self.selected_point_radius = self._io.read_f4le() @property def has_field_bullet_aim(self): if hasattr(self, '_m_has_field_bullet_aim'): return self._m_has_field_bullet_aim self._m_has_field_bullet_aim = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_bullet_aim', None) @property def has_field_ignore_transform(self): if hasattr(self, '_m_has_field_ignore_transform'): return self._m_has_field_ignore_transform self._m_has_field_ignore_transform = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_ignore_transform', None) @property def has_field_element_pendant(self): if hasattr(self, '_m_has_field_element_pendant'): return self._m_has_field_element_pendant self._m_has_field_element_pendant = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_pendant', None) @property def has_field_element_absorb(self): if hasattr(self, '_m_has_field_element_absorb'): return self._m_has_field_element_absorb self._m_has_field_element_absorb = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_absorb', None) @property def has_field_element_drop(self): if hasattr(self, '_m_has_field_element_drop'): return self._m_has_field_element_drop self._m_has_field_element_drop = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_element_drop', None) @property def has_field_selected_point_radius(self): if hasattr(self, '_m_has_field_selected_point_radius'): return self._m_has_field_selected_point_radius self._m_has_field_selected_point_radius = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_selected_point_radius', None) @property def has_field_selected_points(self): if hasattr(self, '_m_has_field_selected_points'): return self._m_has_field_selected_points self._m_has_field_selected_points = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_selected_points', None) @property def has_field_hit_points(self): if hasattr(self, '_m_has_field_hit_points'): return self._m_has_field_hit_points self._m_has_field_hit_points = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_hit_points', None) class RogueGadgetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSumoStageMonsterWaveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SumoStageMonsterWaveType, self.data.value) return getattr(self, '_m_value', None) class BaseActionContainer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_local_id: self.local_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_local_id(self): if hasattr(self, '_m_has_field_local_id'): return self._m_has_field_local_id self._m_has_field_local_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_local_id', None) class EnumConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConditionType, self.data.value) return getattr(self, '_m_value', None) class DailyTaskStatisfiedCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumConditionType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param2', None) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_param3', None) class KvpOfDictAuxTypesVlqBase128LeUConfigHomeFishpond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigHomeFishpond(self._io, self, self._root) class RegionSearchExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigPolygonZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigPolygonZone(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigDangerZone(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigFishingZone(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class AbilityProperty(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class UiInteractExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumUiInteractType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) class ConfigShadowResolutionComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiTacticCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pose: self.pose = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_pose(self): if hasattr(self, '_m_has_field_pose'): return self._m_has_field_pose self._m_has_field_pose = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pose', None) class EnumDropElemControlType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DropElemControlType, self.data.value) return getattr(self, '_m_value', None) class DraftExecTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigCameraSplineBaseTargetLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigCameraSplineBaseTarget(self._io, self, self._root)) class ConfigLightComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_light_type: self.light_type = AuxTypes.String(self._io, self, self._root) if self.has_field_range: self.range = self._io.read_f4le() if self.has_field_color_r: self.color_r = self._io.read_f4le() if self.has_field_color_g: self.color_g = self._io.read_f4le() if self.has_field_color_b: self.color_b = self._io.read_f4le() if self.has_field_angle: self.angle = self._io.read_f4le() if self.has_field_intensity: self.intensity = self._io.read_f4le() if self.has_field_indirect_mult: self.indirect_mult = self._io.read_f4le() @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_range', None) @property def has_field_color_r(self): if hasattr(self, '_m_has_field_color_r'): return self._m_has_field_color_r self._m_has_field_color_r = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_color_r', None) @property def has_field_indirect_mult(self): if hasattr(self, '_m_has_field_indirect_mult'): return self._m_has_field_indirect_mult self._m_has_field_indirect_mult = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_indirect_mult', None) @property def has_field_angle(self): if hasattr(self, '_m_has_field_angle'): return self._m_has_field_angle self._m_has_field_angle = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_angle', None) @property def has_field_intensity(self): if hasattr(self, '_m_has_field_intensity'): return self._m_has_field_intensity self._m_has_field_intensity = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_intensity', None) @property def has_field_color_g(self): if hasattr(self, '_m_has_field_color_g'): return self._m_has_field_color_g self._m_has_field_color_g = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_color_g', None) @property def has_field_color_b(self): if hasattr(self, '_m_has_field_color_b'): return self._m_has_field_color_b self._m_has_field_color_b = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_color_b', None) @property def has_field_light_type(self): if hasattr(self, '_m_has_field_light_type'): return self._m_has_field_light_type self._m_has_field_light_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_light_type', None) class ArrayOfConfigAiMixinSetControllerParameterLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetControllerParameter(self._io, self, self._root)) class ArrayOfSkinColorLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SkinColor(self._io, self, self._root)) class TaaQualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ElementConvertToChargeBarValueMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group: self.group = AuxTypes.String(self._io, self, self._root) @property def has_field_group(self): if hasattr(self, '_m_has_field_group'): return self._m_has_field_group self._m_has_field_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HomeworldModuleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class VoiceOutputMethodEqualityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BartenderEventExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_effect_type: self.effect_type = Output.EnumBartenderEffectType(self._io, self, self._root) if self.has_field_misc_id: self.misc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) @property def has_field_effect_type(self): if hasattr(self, '_m_has_field_effect_type'): return self._m_has_field_effect_type self._m_has_field_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_effect_type', None) @property def has_field_misc_id(self): if hasattr(self, '_m_has_field_misc_id'): return self._m_has_field_misc_id self._m_has_field_misc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_misc_id', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_effect_name', None) class TargetAltitudeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SystemOpenUiConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBigWorldEnvironmentDamageClamp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_reduce_level: self.reduce_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_world_level_cut_threshhold: self.world_level_cut_threshhold = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_reduce_level(self): if hasattr(self, '_m_has_field_reduce_level'): return self._m_has_field_reduce_level self._m_has_field_reduce_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_reduce_level', None) @property def has_field_world_level_cut_threshhold(self): if hasattr(self, '_m_has_field_world_level_cut_threshhold'): return self._m_has_field_world_level_cut_threshhold self._m_has_field_world_level_cut_threshhold = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_world_level_cut_threshhold', None) class Int32NativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class ArrayOfConfigAiMixinSetAnimatorTriggerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetAnimatorTrigger(self._io, self, self._root)) class ElectricCoreLineMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_other_targets: self.other_targets = Output.DispSelectTargets(self._io, self, self._root) if self.has_field_activate_skill_key: self.activate_skill_key = AuxTypes.String(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) @property def has_field_other_targets(self): if hasattr(self, '_m_has_field_other_targets'): return self._m_has_field_other_targets self._m_has_field_other_targets = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_other_targets', None) @property def has_field_activate_skill_key(self): if hasattr(self, '_m_has_field_activate_skill_key'): return self._m_has_field_activate_skill_key self._m_has_field_activate_skill_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_activate_skill_key', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_predicates', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DispConfigLocalGadgetCmd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigLocalGadgetCmd(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLocalGadgetSetMaterialCmd(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigBattleFervorUpdateTriggerByElementBurst(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cd: self.cd = self._io.read_f4le() @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cd', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class HomeAvatarEventCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InputDeviceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfArrayOfDispConfigBaseInterActionLengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfDispConfigBaseInterActionLengthU(self._io, self, self._root)) class DoActionByEntityKillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConstValueTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByAvatarElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class KvpOfDictAuxTypesStringArrayOfElementConvertToChargeBarValueMixinItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfElementConvertToChargeBarValueMixinItemLengthU(self._io, self, self._root) class MultistageStageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEntityBlackGrp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_black: self.is_black = self._io.read_u1() if self.has_field_entity_type: self.entity_type = Output.EnumEntityType(self._io, self, self._root) if self.has_field_entity_ids: self.entity_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_is_black(self): if hasattr(self, '_m_has_field_is_black'): return self._m_has_field_is_black self._m_has_field_is_black = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_black', None) @property def has_field_entity_type(self): if hasattr(self, '_m_has_field_entity_type'): return self._m_has_field_entity_type self._m_has_field_entity_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_entity_type', None) @property def has_field_entity_ids(self): if hasattr(self, '_m_has_field_entity_ids'): return self._m_has_field_entity_ids self._m_has_field_entity_ids = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_entity_ids', None) class CutsceneInitPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSoundBankUnloadPolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SoundBankUnloadPolicy, self.data.value) return getattr(self, '_m_value', None) class EnumQteType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteType, self.data.value) return getattr(self, '_m_value', None) class FishPoolExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSteerInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_steer_type: self.steer_type = Output.EnumDialogSteerType(self._io, self, self._root) if self.has_field_use_angle: self.use_angle = self._io.read_u1() if self.has_field_steer_dir: self.steer_dir = Output.Vector(self._io, self, self._root) if self.has_field_steer_angle: self.steer_angle = self._io.read_f4le() if self.has_field_use_steer_anim: self.use_steer_anim = self._io.read_u1() if self.has_field_interrupt_freestyle: self.interrupt_freestyle = self._io.read_u1() if self.has_field_force_steer: self.force_steer = self._io.read_u1() if self.has_field_target_npc_alias: self.target_npc_alias = AuxTypes.String(self._io, self, self._root) @property def has_field_use_steer_anim(self): if hasattr(self, '_m_has_field_use_steer_anim'): return self._m_has_field_use_steer_anim self._m_has_field_use_steer_anim = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_use_steer_anim', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_interrupt_freestyle(self): if hasattr(self, '_m_has_field_interrupt_freestyle'): return self._m_has_field_interrupt_freestyle self._m_has_field_interrupt_freestyle = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_interrupt_freestyle', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_steer_angle(self): if hasattr(self, '_m_has_field_steer_angle'): return self._m_has_field_steer_angle self._m_has_field_steer_angle = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_steer_angle', None) @property def has_field_steer_type(self): if hasattr(self, '_m_has_field_steer_type'): return self._m_has_field_steer_type self._m_has_field_steer_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_steer_type', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_steer_dir(self): if hasattr(self, '_m_has_field_steer_dir'): return self._m_has_field_steer_dir self._m_has_field_steer_dir = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_steer_dir', None) @property def has_field_target_npc_alias(self): if hasattr(self, '_m_has_field_target_npc_alias'): return self._m_has_field_target_npc_alias self._m_has_field_target_npc_alias = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_target_npc_alias', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_use_angle(self): if hasattr(self, '_m_has_field_use_angle'): return self._m_has_field_use_angle self._m_has_field_use_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_angle', None) @property def has_field_force_steer(self): if hasattr(self, '_m_has_field_force_steer'): return self._m_has_field_force_steer self._m_has_field_force_steer = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_force_steer', None) class KvpOfDictAuxTypesStringArrayOfEnumNeuronNameLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfEnumNeuronNameLengthU(self._io, self, self._root) class ConfigAiuiSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_has_direction_indicator: self.has_direction_indicator = self._io.read_u1() @property def has_field_has_direction_indicator(self): if hasattr(self, '_m_has_field_has_direction_indicator'): return self._m_has_field_has_direction_indicator self._m_has_field_has_direction_indicator = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_has_direction_indicator', None) class ConfigEntityTags(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_init_tags: self.init_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_init_tags(self): if hasattr(self, '_m_has_field_init_tags'): return self._m_has_field_init_tags self._m_has_field_init_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_init_tags', None) class EnumClimateSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ClimateSourceType, self.data.value) return getattr(self, '_m_value', None) class RogueMonsterPoolDifficultyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActionTokenSourceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumVoiceLanguageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VoiceLanguageType, self.data.value) return getattr(self, '_m_value', None) class BinaryTool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HomeWorldPlantExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAvatarEquipChangedCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ConfigAiMeleeChargeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_start_distance_min: self.start_distance_min = self._io.read_f4le() if self.has_field_start_distance_max: self.start_distance_max = self._io.read_f4le() if self.has_field_stop_distance: self.stop_distance = self._io.read_f4le() if self.has_field_inner_distance: self.inner_distance = self._io.read_f4le() if self.has_field_speed_level_inner: self.speed_level_inner = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_melee_slot: self.use_melee_slot = self._io.read_u1() @property def has_field_speed_level_inner(self): if hasattr(self, '_m_has_field_speed_level_inner'): return self._m_has_field_speed_level_inner self._m_has_field_speed_level_inner = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_speed_level_inner', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_use_melee_slot(self): if hasattr(self, '_m_has_field_use_melee_slot'): return self._m_has_field_use_melee_slot self._m_has_field_use_melee_slot = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_use_melee_slot', None) @property def has_field_stop_distance(self): if hasattr(self, '_m_has_field_stop_distance'): return self._m_has_field_stop_distance self._m_has_field_stop_distance = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_stop_distance', None) @property def has_field_start_distance_max(self): if hasattr(self, '_m_has_field_start_distance_max'): return self._m_has_field_start_distance_max self._m_has_field_start_distance_max = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_start_distance_max', None) @property def has_field_start_distance_min(self): if hasattr(self, '_m_has_field_start_distance_min'): return self._m_has_field_start_distance_min self._m_has_field_start_distance_min = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_start_distance_min', None) @property def has_field_inner_distance(self): if hasattr(self, '_m_has_field_inner_distance'): return self._m_has_field_inner_distance self._m_has_field_inner_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_inner_distance', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class OfferingVersionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_offering_id: self.offering_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_limit: self.level_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_offering_id(self): if hasattr(self, '_m_has_field_offering_id'): return self._m_has_field_offering_id self._m_has_field_offering_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_offering_id', None) @property def has_field_level_limit(self): if hasattr(self, '_m_has_field_level_limit'): return self._m_has_field_level_limit self._m_has_field_level_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_limit', None) class PsActivitiesActivityConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_name: self.activity_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_desc: self.activity_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_category: self.category = Output.EnumPsActivitiesCategoryType(self._io, self, self._root) if self.has_field_available_by_default: self.available_by_default = self._io.read_u1() if self.has_field_is_required_for_completion: self.is_required_for_completion = self._io.read_u1() if self.has_field_hidden: self.hidden = self._io.read_u1() if self.has_field_is_online_multiplay: self.is_online_multiplay = self._io.read_u1() if self.has_field_large_icon: self.large_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_small_icon: self.small_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_object_id: self.object_id = AuxTypes.String(self._io, self, self._root) if self.has_field_export_version: self.export_version = AuxTypes.String(self._io, self, self._root) @property def has_field_activity_desc(self): if hasattr(self, '_m_has_field_activity_desc'): return self._m_has_field_activity_desc self._m_has_field_activity_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_desc', None) @property def has_field_category(self): if hasattr(self, '_m_has_field_category'): return self._m_has_field_category self._m_has_field_category = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_category', None) @property def has_field_activity_name(self): if hasattr(self, '_m_has_field_activity_name'): return self._m_has_field_activity_name self._m_has_field_activity_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_name', None) @property def has_field_is_online_multiplay(self): if hasattr(self, '_m_has_field_is_online_multiplay'): return self._m_has_field_is_online_multiplay self._m_has_field_is_online_multiplay = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_online_multiplay', None) @property def has_field_small_icon(self): if hasattr(self, '_m_has_field_small_icon'): return self._m_has_field_small_icon self._m_has_field_small_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_small_icon', None) @property def has_field_is_required_for_completion(self): if hasattr(self, '_m_has_field_is_required_for_completion'): return self._m_has_field_is_required_for_completion self._m_has_field_is_required_for_completion = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_required_for_completion', None) @property def has_field_available_by_default(self): if hasattr(self, '_m_has_field_available_by_default'): return self._m_has_field_available_by_default self._m_has_field_available_by_default = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_available_by_default', None) @property def has_field_export_version(self): if hasattr(self, '_m_has_field_export_version'): return self._m_has_field_export_version self._m_has_field_export_version = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_export_version', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_object_id(self): if hasattr(self, '_m_has_field_object_id'): return self._m_has_field_object_id self._m_has_field_object_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_object_id', None) @property def has_field_hidden(self): if hasattr(self, '_m_has_field_hidden'): return self._m_has_field_hidden self._m_has_field_hidden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_hidden', None) @property def has_field_large_icon(self): if hasattr(self, '_m_has_field_large_icon'): return self._m_has_field_large_icon self._m_has_field_large_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_large_icon', None) class ByCurrentSceneId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_scene_ids: self.scene_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_scene_ids(self): if hasattr(self, '_m_has_field_scene_ids'): return self._m_has_field_scene_ids self._m_has_field_scene_ids = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_ids', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class AttachModifierByStackingMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_stacking_modifier: self.stacking_modifier = AuxTypes.String(self._io, self, self._root) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def has_field_stacking_modifier(self): if hasattr(self, '_m_has_field_stacking_modifier'): return self._m_has_field_stacking_modifier self._m_has_field_stacking_modifier = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_stacking_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ActivityGachaTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNormalStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseStateIdInfo(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_animator_states: self.animator_states = Output.DictOfAuxTypesStringArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_move_type: self.move_type = Output.EnumMoveType(self._io, self, self._root) if self.has_field_combat_move_on_water: self.combat_move_on_water = self._io.read_u1() if self.has_field_can_do_skill: self.can_do_skill = self._io.read_u1() if self.has_field_can_do_skill_start: self.can_do_skill_start = self._io.read_f4le() if self.has_field_can_do_skill_end: self.can_do_skill_end = self._io.read_f4le() if self.has_field_can_sync_move: self.can_sync_move = self._io.read_u1() if self.has_field_culling_model_always_animate: self.culling_model_always_animate = self._io.read_u1() if self.has_field_add_endure: self.add_endure = self._io.read_f4le() if self.has_field_mass_ratio: self.mass_ratio = self._io.read_f4le() if self.has_field_reset_animator_trigger_on_enter: self.reset_animator_trigger_on_enter = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_reset_animator_trigger_on_exit: self.reset_animator_trigger_on_exit = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_set_animator_boolean: self.set_animator_boolean = Output.ArrayOfConfigAnimatorBooleanLengthU(self._io, self, self._root) if self.has_field_set_animator_float: self.set_animator_float = Output.ArrayOfConfigAnimatorFloatLengthU(self._io, self, self._root) if self.has_field_enable_rag_doll: self.enable_rag_doll = self._io.read_u1() if self.has_field_need_face_to_anim_param: self.need_face_to_anim_param = self._io.read_u1() if self.has_field_enable_ccd: self.enable_ccd = self._io.read_u1() if self.has_field_handle_animator_state_immediately: self.handle_animator_state_immediately = self._io.read_u1() @property def has_field_can_do_skill_start(self): if hasattr(self, '_m_has_field_can_do_skill_start'): return self._m_has_field_can_do_skill_start self._m_has_field_can_do_skill_start = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_can_do_skill_start', None) @property def has_field_enable_rag_doll(self): if hasattr(self, '_m_has_field_enable_rag_doll'): return self._m_has_field_enable_rag_doll self._m_has_field_enable_rag_doll = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_enable_rag_doll', None) @property def has_field_can_sync_move(self): if hasattr(self, '_m_has_field_can_sync_move'): return self._m_has_field_can_sync_move self._m_has_field_can_sync_move = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_can_sync_move', None) @property def has_field_can_do_skill(self): if hasattr(self, '_m_has_field_can_do_skill'): return self._m_has_field_can_do_skill self._m_has_field_can_do_skill = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_can_do_skill', None) @property def has_field_add_endure(self): if hasattr(self, '_m_has_field_add_endure'): return self._m_has_field_add_endure self._m_has_field_add_endure = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_add_endure', None) @property def has_field_animator_states(self): if hasattr(self, '_m_has_field_animator_states'): return self._m_has_field_animator_states self._m_has_field_animator_states = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_animator_states', None) @property def has_field_culling_model_always_animate(self): if hasattr(self, '_m_has_field_culling_model_always_animate'): return self._m_has_field_culling_model_always_animate self._m_has_field_culling_model_always_animate = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_culling_model_always_animate', None) @property def has_field_enable_ccd(self): if hasattr(self, '_m_has_field_enable_ccd'): return self._m_has_field_enable_ccd self._m_has_field_enable_ccd = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_enable_ccd', None) @property def has_field_set_animator_float(self): if hasattr(self, '_m_has_field_set_animator_float'): return self._m_has_field_set_animator_float self._m_has_field_set_animator_float = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_set_animator_float', None) @property def has_field_mass_ratio(self): if hasattr(self, '_m_has_field_mass_ratio'): return self._m_has_field_mass_ratio self._m_has_field_mass_ratio = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_mass_ratio', None) @property def priority(self): if hasattr(self, '_m_priority'): return self._m_priority self._m_priority = self.base.priority return getattr(self, '_m_priority', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_move_type', None) @property def has_field_can_do_skill_end(self): if hasattr(self, '_m_has_field_can_do_skill_end'): return self._m_has_field_can_do_skill_end self._m_has_field_can_do_skill_end = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_can_do_skill_end', None) @property def has_field_reset_animator_trigger_on_enter(self): if hasattr(self, '_m_has_field_reset_animator_trigger_on_enter'): return self._m_has_field_reset_animator_trigger_on_enter self._m_has_field_reset_animator_trigger_on_enter = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_reset_animator_trigger_on_enter', None) @property def has_field_combat_move_on_water(self): if hasattr(self, '_m_has_field_combat_move_on_water'): return self._m_has_field_combat_move_on_water self._m_has_field_combat_move_on_water = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_combat_move_on_water', None) @property def has_field_need_face_to_anim_param(self): if hasattr(self, '_m_has_field_need_face_to_anim_param'): return self._m_has_field_need_face_to_anim_param self._m_has_field_need_face_to_anim_param = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_need_face_to_anim_param', None) @property def has_field_handle_animator_state_immediately(self): if hasattr(self, '_m_has_field_handle_animator_state_immediately'): return self._m_has_field_handle_animator_state_immediately self._m_has_field_handle_animator_state_immediately = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_handle_animator_state_immediately', None) @property def has_field_set_animator_boolean(self): if hasattr(self, '_m_has_field_set_animator_boolean'): return self._m_has_field_set_animator_boolean self._m_has_field_set_animator_boolean = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_set_animator_boolean', None) @property def has_field_reset_animator_trigger_on_exit(self): if hasattr(self, '_m_has_field_reset_animator_trigger_on_exit'): return self._m_has_field_reset_animator_trigger_on_exit self._m_has_field_reset_animator_trigger_on_exit = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_reset_animator_trigger_on_exit', None) class EnumIrodoriChessCardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideMapClickCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mark_id: self.mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_only_single_click: self.only_single_click = self._io.read_u1() @property def has_field_mark_id(self): if hasattr(self, '_m_has_field_mark_id'): return self._m_has_field_mark_id self._m_has_field_mark_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mark_id', None) @property def has_field_only_single_click(self): if hasattr(self, '_m_has_field_only_single_click'): return self._m_has_field_only_single_click self._m_has_field_only_single_click = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_only_single_click', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ArrayOfConfigLevelPolygonLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelPolygon(self._io, self, self._root)) class ConfigAiReturnToBornPosData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_fadeout_begin_time: self.fadeout_begin_time = self._io.read_f4le() if self.has_field_fadeout_end_time: self.fadeout_end_time = self._io.read_f4le() if self.has_field_spacial: self.spacial = self._io.read_u1() if self.has_field_perform_time: self.perform_time = self._io.read_f4le() @property def has_field_fadeout_begin_time(self): if hasattr(self, '_m_has_field_fadeout_begin_time'): return self._m_has_field_fadeout_begin_time self._m_has_field_fadeout_begin_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fadeout_begin_time', None) @property def has_field_perform_time(self): if hasattr(self, '_m_has_field_perform_time'): return self._m_has_field_perform_time self._m_has_field_perform_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_perform_time', None) @property def has_field_fadeout_end_time(self): if hasattr(self, '_m_has_field_fadeout_end_time'): return self._m_has_field_fadeout_end_time self._m_has_field_fadeout_end_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fadeout_end_time', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_spacial(self): if hasattr(self, '_m_has_field_spacial'): return self._m_has_field_spacial self._m_has_field_spacial = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_spacial', None) class UniqueModifierCondComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityEntryConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_type: self.activity_type = Output.EnumNewActivityType(self._io, self, self._root) if self.has_field_sort_priority: self.sort_priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_tab_icon: self.tab_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_banner_path: self.banner_path = AuxTypes.String(self._io, self, self._root) if self.has_field_banner_effect: self.banner_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_tab_name: self.tab_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_duration: self.duration = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_activity_type(self): if hasattr(self, '_m_has_field_activity_type'): return self._m_has_field_activity_type self._m_has_field_activity_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_type', None) @property def has_field_tab_name(self): if hasattr(self, '_m_has_field_tab_name'): return self._m_has_field_tab_name self._m_has_field_tab_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_tab_name', None) @property def has_field_banner_effect(self): if hasattr(self, '_m_has_field_banner_effect'): return self._m_has_field_banner_effect self._m_has_field_banner_effect = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_banner_effect', None) @property def has_field_banner_path(self): if hasattr(self, '_m_has_field_banner_path'): return self._m_has_field_banner_path self._m_has_field_banner_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_banner_path', None) @property def has_field_tab_icon(self): if hasattr(self, '_m_has_field_tab_icon'): return self._m_has_field_tab_icon self._m_has_field_tab_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tab_icon', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_duration', None) @property def has_field_sort_priority(self): if hasattr(self, '_m_has_field_sort_priority'): return self._m_has_field_sort_priority self._m_has_field_sort_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort_priority', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigEliteShield(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_row: self.row = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_shield_damage_ratios_map: self.shield_damage_ratios_map = Output.DictOfAuxTypesStringConfigEliteShieldResistance(self._io, self, self._root) @property def has_field_row(self): if hasattr(self, '_m_has_field_row'): return self._m_has_field_row self._m_has_field_row = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_row', None) @property def has_field_shield_damage_ratios_map(self): if hasattr(self, '_m_has_field_shield_damage_ratios_map'): return self._m_has_field_shield_damage_ratios_map self._m_has_field_shield_damage_ratios_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_shield_damage_ratios_map', None) class ConfigJudgeGroupEntityDirectionHasBlock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_group_entity_list: self.group_entity_list = Output.ArrayOfConfigJudgeGroupEntityLengthU(self._io, self, self._root) if self.has_field_detect_distance: self.detect_distance = self._io.read_f4le() @property def has_field_group_entity_list(self): if hasattr(self, '_m_has_field_group_entity_list'): return self._m_has_field_group_entity_list self._m_has_field_group_entity_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_group_entity_list', None) @property def has_field_detect_distance(self): if hasattr(self, '_m_has_field_detect_distance'): return self._m_has_field_detect_distance self._m_has_field_detect_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_distance', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class EnumBattlePassMissionRefreshType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BattlePassMissionRefreshType, self.data.value) return getattr(self, '_m_value', None) class BitwiseOperatorComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GadgetInteractCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumInteractCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ConfigActionTokenChannelGroupInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_low_level_dist: self.low_level_dist = self._io.read_f4le() if self.has_field_low_level_dist_token: self.low_level_dist_token = Output.DictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root) if self.has_field_action_source_token: self.action_source_token = Output.DictOfEnumActionTokenSourceTypeDictOfEnumEntityTokenActionTypeConfigEntityActionTokenGroup(self._io, self, self._root) if self.has_field_cfg: self.cfg = Output.DictOfAuxTypesVlqBase128LeSConfigActionTokenChannel(self._io, self, self._root) @property def has_field_low_level_dist(self): if hasattr(self, '_m_has_field_low_level_dist'): return self._m_has_field_low_level_dist self._m_has_field_low_level_dist = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_low_level_dist', None) @property def has_field_low_level_dist_token(self): if hasattr(self, '_m_has_field_low_level_dist_token'): return self._m_has_field_low_level_dist_token self._m_has_field_low_level_dist_token = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_low_level_dist_token', None) @property def has_field_action_source_token(self): if hasattr(self, '_m_has_field_action_source_token'): return self._m_has_field_action_source_token self._m_has_field_action_source_token = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_action_source_token', None) @property def has_field_cfg(self): if hasattr(self, '_m_has_field_cfg'): return self._m_has_field_cfg self._m_has_field_cfg = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cfg', None) class ConfigTileElement(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_element_durability: self.element_durability = self._io.read_f4le() if self.has_field_is_element_durability_mutable: self.is_element_durability_mutable = self._io.read_u1() @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def has_field_element_durability(self): if hasattr(self, '_m_has_field_element_durability'): return self._m_has_field_element_durability self._m_has_field_element_durability = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_element_durability', None) @property def has_field_is_element_durability_mutable(self): if hasattr(self, '_m_has_field_is_element_durability_mutable'): return self._m_has_field_is_element_durability_mutable self._m_has_field_is_element_durability_mutable = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_element_durability_mutable', None) class HomeworldServerEventMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_editor_modifier_names: self.editor_modifier_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_world_modifier_names: self.world_modifier_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_editor_modifier_names(self): if hasattr(self, '_m_has_field_editor_modifier_names'): return self._m_has_field_editor_modifier_names self._m_has_field_editor_modifier_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_editor_modifier_names', None) @property def has_field_world_modifier_names(self): if hasattr(self, '_m_has_field_world_modifier_names'): return self._m_has_field_world_modifier_names self._m_has_field_world_modifier_names = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_world_modifier_names', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class GadgetExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DungeonCondConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumDungeonCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class MechanicusExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivitySummerTimeStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideClimateTypeCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) if self.has_field_is_equal: self.is_equal = self._io.read_u1() @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def has_field_is_equal(self): if hasattr(self, '_m_has_field_is_equal'): return self._m_has_field_is_equal self._m_has_field_is_equal = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_equal', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class QuestGuideNpcSelectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigLookAtInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enable_head: self.enable_head = self._io.read_u1() if self.has_field_use_target_pos: self.use_target_pos = self._io.read_u1() if self.has_field_enable_absolute: self.enable_absolute = self._io.read_u1() if self.has_field_target_offset: self.target_offset = Output.Vector(self._io, self, self._root) if self.has_field_target_position: self.target_position = Output.Vector(self._io, self, self._root) if self.has_field_head_rotate_vec: self.head_rotate_vec = Output.Vector(self._io, self, self._root) if self.has_field_enable_body: self.enable_body = self._io.read_u1() if self.has_field_body_angle: self.body_angle = self._io.read_f4le() if self.has_field_head_turn_time: self.head_turn_time = self._io.read_f4le() if self.has_field_body_turn_time: self.body_turn_time = self._io.read_f4le() if self.has_field_target_npc_alias: self.target_npc_alias = AuxTypes.String(self._io, self, self._root) if self.has_field_look_at_target_type: self.look_at_target_type = Output.EnumLookAtTargetType(self._io, self, self._root) if self.has_field_target_npc_rotate_vec_plus: self.target_npc_rotate_vec_plus = Output.Vector(self._io, self, self._root) if self.has_field_open_back_protect: self.open_back_protect = self._io.read_u1() if self.has_field_back_protect_angle: self.back_protect_angle = self._io.read_f4le() @property def has_field_target_offset(self): if hasattr(self, '_m_has_field_target_offset'): return self._m_has_field_target_offset self._m_has_field_target_offset = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_target_offset', None) @property def has_field_target_position(self): if hasattr(self, '_m_has_field_target_position'): return self._m_has_field_target_position self._m_has_field_target_position = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_target_position', None) @property def has_field_enable_absolute(self): if hasattr(self, '_m_has_field_enable_absolute'): return self._m_has_field_enable_absolute self._m_has_field_enable_absolute = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_enable_absolute', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_look_at_target_type(self): if hasattr(self, '_m_has_field_look_at_target_type'): return self._m_has_field_look_at_target_type self._m_has_field_look_at_target_type = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_look_at_target_type', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_open_back_protect(self): if hasattr(self, '_m_has_field_open_back_protect'): return self._m_has_field_open_back_protect self._m_has_field_open_back_protect = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_open_back_protect', None) @property def has_field_enable_body(self): if hasattr(self, '_m_has_field_enable_body'): return self._m_has_field_enable_body self._m_has_field_enable_body = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_enable_body', None) @property def has_field_back_protect_angle(self): if hasattr(self, '_m_has_field_back_protect_angle'): return self._m_has_field_back_protect_angle self._m_has_field_back_protect_angle = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_back_protect_angle', None) @property def has_field_target_npc_rotate_vec_plus(self): if hasattr(self, '_m_has_field_target_npc_rotate_vec_plus'): return self._m_has_field_target_npc_rotate_vec_plus self._m_has_field_target_npc_rotate_vec_plus = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_target_npc_rotate_vec_plus', None) @property def has_field_enable_head(self): if hasattr(self, '_m_has_field_enable_head'): return self._m_has_field_enable_head self._m_has_field_enable_head = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_enable_head', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_use_target_pos(self): if hasattr(self, '_m_has_field_use_target_pos'): return self._m_has_field_use_target_pos self._m_has_field_use_target_pos = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_use_target_pos', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_body_turn_time(self): if hasattr(self, '_m_has_field_body_turn_time'): return self._m_has_field_body_turn_time self._m_has_field_body_turn_time = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_body_turn_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_target_npc_alias(self): if hasattr(self, '_m_has_field_target_npc_alias'): return self._m_has_field_target_npc_alias self._m_has_field_target_npc_alias = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_target_npc_alias', None) @property def has_field_head_turn_time(self): if hasattr(self, '_m_has_field_head_turn_time'): return self._m_has_field_head_turn_time self._m_has_field_head_turn_time = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_head_turn_time', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_body_angle(self): if hasattr(self, '_m_has_field_body_angle'): return self._m_has_field_body_angle self._m_has_field_body_angle = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_body_angle', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_head_rotate_vec(self): if hasattr(self, '_m_has_field_head_rotate_vec'): return self._m_has_field_head_rotate_vec self._m_has_field_head_rotate_vec = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_head_rotate_vec', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class VehicleMarkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mark_icon_type_name: self.mark_icon_type_name = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_mark_icon_type_name(self): if hasattr(self, '_m_has_field_mark_icon_type_name'): return self._m_has_field_mark_icon_type_name self._m_has_field_mark_icon_type_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mark_icon_type_name', None) class SectrStreamTreeObjectRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DungeonQuestCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_quest_id_list: self.main_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_main_quest_id_list(self): if hasattr(self, '_m_has_field_main_quest_id_list'): return self._m_has_field_main_quest_id_list self._m_has_field_main_quest_id_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_main_quest_id_list', None) class ConfigWidgetWaterSpriteToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_group_name: self.ability_group_name = AuxTypes.String(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def has_field_ability_group_name(self): if hasattr(self, '_m_has_field_ability_group_name'): return self._m_has_field_ability_group_name self._m_has_field_ability_group_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_group_name', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class MechanicBuildingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_level1: self.special_effect_level1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_level2: self.special_effect_level2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_id1: self.special_effect_id1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_id2: self.special_effect_id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_desc1: self.special_effect_desc1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_effect_desc2: self.special_effect_desc2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_level: self.max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfSgvConfigLengthS(self._io, self, self._root) if self.has_field_build_limit: self.build_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_enable_rotate: self.is_enable_rotate = self._io.read_u1() if self.has_field_default_dungeon_list: self.default_dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_element_type: self.element_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_special_effect_desc1(self): if hasattr(self, '_m_has_field_special_effect_desc1'): return self._m_has_field_special_effect_desc1 self._m_has_field_special_effect_desc1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_special_effect_desc1', None) @property def has_field_special_effect_id1(self): if hasattr(self, '_m_has_field_special_effect_id1'): return self._m_has_field_special_effect_id1 self._m_has_field_special_effect_id1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_special_effect_id1', None) @property def has_field_is_enable_rotate(self): if hasattr(self, '_m_has_field_is_enable_rotate'): return self._m_has_field_is_enable_rotate self._m_has_field_is_enable_rotate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_is_enable_rotate', None) @property def has_field_special_effect_id2(self): if hasattr(self, '_m_has_field_special_effect_id2'): return self._m_has_field_special_effect_id2 self._m_has_field_special_effect_id2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_special_effect_id2', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_max_level(self): if hasattr(self, '_m_has_field_max_level'): return self._m_has_field_max_level self._m_has_field_max_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_max_level', None) @property def has_field_build_limit(self): if hasattr(self, '_m_has_field_build_limit'): return self._m_has_field_build_limit self._m_has_field_build_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_build_limit', None) @property def has_field_special_effect_desc2(self): if hasattr(self, '_m_has_field_special_effect_desc2'): return self._m_has_field_special_effect_desc2 self._m_has_field_special_effect_desc2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_special_effect_desc2', None) @property def has_field_special_effect_level2(self): if hasattr(self, '_m_has_field_special_effect_level2'): return self._m_has_field_special_effect_level2 self._m_has_field_special_effect_level2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_special_effect_level2', None) @property def has_field_special_effect_level1(self): if hasattr(self, '_m_has_field_special_effect_level1'): return self._m_has_field_special_effect_level1 self._m_has_field_special_effect_level1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_special_effect_level1', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_default_dungeon_list(self): if hasattr(self, '_m_has_field_default_dungeon_list'): return self._m_has_field_default_dungeon_list self._m_has_field_default_dungeon_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_default_dungeon_list', None) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_element_type', None) class DragonSpineMissionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WidgetCameraActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUConfigCoopInteractionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigCoopInteractionGroup(self._io, self, self._root)) class AutoDefenceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.EntityDefenceMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cost_stamina_ratio: self.cost_stamina_ratio = self._io.read_f4le() @property def defend_count_interval(self): if hasattr(self, '_m_defend_count_interval'): return self._m_defend_count_interval self._m_defend_count_interval = self.base.defend_count_interval return getattr(self, '_m_defend_count_interval', None) @property def defend_probability_delta(self): if hasattr(self, '_m_defend_probability_delta'): return self._m_defend_probability_delta self._m_defend_probability_delta = self.base.defend_probability_delta return getattr(self, '_m_defend_probability_delta', None) @property def state_i_ds(self): if hasattr(self, '_m_state_i_ds'): return self._m_state_i_ds self._m_state_i_ds = self.base.state_i_ds return getattr(self, '_m_state_i_ds', None) @property def has_field_cost_stamina_ratio(self): if hasattr(self, '_m_has_field_cost_stamina_ratio'): return self._m_has_field_cost_stamina_ratio self._m_has_field_cost_stamina_ratio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cost_stamina_ratio', None) @property def defend_trigger_id(self): if hasattr(self, '_m_defend_trigger_id'): return self._m_defend_trigger_id self._m_defend_trigger_id = self.base.defend_trigger_id return getattr(self, '_m_defend_trigger_id', None) @property def defend_probability(self): if hasattr(self, '_m_defend_probability'): return self._m_defend_probability self._m_defend_probability = self.base.defend_probability return getattr(self, '_m_defend_probability', None) @property def always_recover(self): if hasattr(self, '_m_always_recover'): return self._m_always_recover self._m_always_recover = self.base.always_recover return getattr(self, '_m_always_recover', None) @property def can_defence_while_endure_full(self): if hasattr(self, '_m_can_defence_while_endure_full'): return self._m_can_defence_while_endure_full self._m_can_defence_while_endure_full = self.base.can_defence_while_endure_full return getattr(self, '_m_can_defence_while_endure_full', None) @property def defend_angle(self): if hasattr(self, '_m_defend_angle'): return self._m_defend_angle self._m_defend_angle = self.base.defend_angle return getattr(self, '_m_defend_angle', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def defend_time_interval(self): if hasattr(self, '_m_defend_time_interval'): return self._m_defend_time_interval self._m_defend_time_interval = self.base.defend_time_interval return getattr(self, '_m_defend_time_interval', None) class EnumEffectTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EffectTargetType, self.data.value) return getattr(self, '_m_value', None) class ByCurTeamHasFeatureTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_feature_tag_id: self.feature_tag_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_feature_tag_id(self): if hasattr(self, '_m_has_field_feature_tag_id'): return self._m_has_field_feature_tag_id self._m_has_field_feature_tag_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_feature_tag_id', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DailyTaskLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_player_level: self.min_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_player_level: self.max_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_revise_level: self.group_revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_drop_id: self.score_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_preview_reward_id: self.score_preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_score_preview_reward_id(self): if hasattr(self, '_m_has_field_score_preview_reward_id'): return self._m_has_field_score_preview_reward_id self._m_has_field_score_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_score_preview_reward_id', None) @property def has_field_min_player_level(self): if hasattr(self, '_m_has_field_min_player_level'): return self._m_has_field_min_player_level self._m_has_field_min_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_min_player_level', None) @property def has_field_max_player_level(self): if hasattr(self, '_m_has_field_max_player_level'): return self._m_has_field_max_player_level self._m_has_field_max_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_player_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_score_drop_id(self): if hasattr(self, '_m_has_field_score_drop_id'): return self._m_has_field_score_drop_id self._m_has_field_score_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_score_drop_id', None) @property def has_field_group_revise_level(self): if hasattr(self, '_m_has_field_group_revise_level'): return self._m_has_field_group_revise_level self._m_has_field_group_revise_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_group_revise_level', None) class ConfigKeyInput(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_key_id: self.key_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_input_key_code: self.input_key_code = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_ability_cd: self.ability_cd = self._io.read_f4le() @property def has_field_key_id(self): if hasattr(self, '_m_has_field_key_id'): return self._m_has_field_key_id self._m_has_field_key_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key_id', None) @property def has_field_input_key_code(self): if hasattr(self, '_m_has_field_input_key_code'): return self._m_has_field_input_key_code self._m_has_field_input_key_code = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_input_key_code', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_ability_cd(self): if hasattr(self, '_m_has_field_ability_cd'): return self._m_has_field_ability_cd self._m_has_field_ability_cd = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ability_cd', None) class ArrayOfAudioTreeDataAssetNamePatternLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioTreeDataAssetNamePattern(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeUDispConfigBaseWidgetToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUDispConfigBaseWidgetToy(self._io, self, self._root)) class WeaponPromoteExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCombatLock(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_lock_shape: self.lock_shape = AuxTypes.String(self._io, self, self._root) if self.has_field_deny_lock_on: self.deny_lock_on = self._io.read_u1() if self.has_field_lock_weight_yaxis_param: self.lock_weight_yaxis_param = self._io.read_f4le() if self.has_field_lock_weight_yaxis_threshold: self.lock_weight_yaxis_threshold = self._io.read_f4le() if self.has_field_lock_type: self.lock_type = AuxTypes.String(self._io, self, self._root) if self.has_field_override_range: self.override_range = self._io.read_f4le() if self.has_field_override_normal_pri: self.override_normal_pri = self._io.read_f4le() if self.has_field_override_combat_pri: self.override_combat_pri = self._io.read_f4le() @property def has_field_lock_weight_yaxis_threshold(self): if hasattr(self, '_m_has_field_lock_weight_yaxis_threshold'): return self._m_has_field_lock_weight_yaxis_threshold self._m_has_field_lock_weight_yaxis_threshold = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_lock_weight_yaxis_threshold', None) @property def has_field_lock_shape(self): if hasattr(self, '_m_has_field_lock_shape'): return self._m_has_field_lock_shape self._m_has_field_lock_shape = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_lock_shape', None) @property def has_field_override_combat_pri(self): if hasattr(self, '_m_has_field_override_combat_pri'): return self._m_has_field_override_combat_pri self._m_has_field_override_combat_pri = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_override_combat_pri', None) @property def has_field_lock_type(self): if hasattr(self, '_m_has_field_lock_type'): return self._m_has_field_lock_type self._m_has_field_lock_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_lock_type', None) @property def has_field_override_range(self): if hasattr(self, '_m_has_field_override_range'): return self._m_has_field_override_range self._m_has_field_override_range = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_override_range', None) @property def has_field_lock_weight_yaxis_param(self): if hasattr(self, '_m_has_field_lock_weight_yaxis_param'): return self._m_has_field_lock_weight_yaxis_param self._m_has_field_lock_weight_yaxis_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_lock_weight_yaxis_param', None) @property def has_field_override_normal_pri(self): if hasattr(self, '_m_has_field_override_normal_pri'): return self._m_has_field_override_normal_pri self._m_has_field_override_normal_pri = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_override_normal_pri', None) @property def has_field_deny_lock_on(self): if hasattr(self, '_m_has_field_deny_lock_on'): return self._m_has_field_deny_lock_on self._m_has_field_deny_lock_on = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_deny_lock_on', None) class EnumBlossomRefreshType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlossomRefreshType, self.data.value) return getattr(self, '_m_value', None) class BoredActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMultistageStageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MultistageStageType, self.data.value) return getattr(self, '_m_value', None) class ConfigBaseAttackPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_type: self.trigger_type = Output.EnumTriggerType(self._io, self, self._root) if self.has_field_check_hit_layer_type: self.check_hit_layer_type = Output.EnumCheckHitLayerType(self._io, self, self._root) if self.has_field_hit_scene: self.hit_scene = Output.ConfigHitScene(self._io, self, self._root) if self.has_field_trigger_cd: self.trigger_cd = self._io.read_f4le() if self.has_field_filter_by_frame: self.filter_by_frame = self._io.read_u1() if self.has_field_ignore_massive: self.ignore_massive = self._io.read_u1() if self.has_field_entity_attack_filter: self.entity_attack_filter = Output.EnumEntityAttackFilter(self._io, self, self._root) if self.has_field_massive_attack_ratio: self.massive_attack_ratio = self._io.read_f4le() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) @property def has_field_check_hit_layer_type(self): if hasattr(self, '_m_has_field_check_hit_layer_type'): return self._m_has_field_check_hit_layer_type self._m_has_field_check_hit_layer_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_check_hit_layer_type', None) @property def has_field_ignore_massive(self): if hasattr(self, '_m_has_field_ignore_massive'): return self._m_has_field_ignore_massive self._m_has_field_ignore_massive = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_ignore_massive', None) @property def has_field_entity_attack_filter(self): if hasattr(self, '_m_has_field_entity_attack_filter'): return self._m_has_field_entity_attack_filter self._m_has_field_entity_attack_filter = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_entity_attack_filter', None) @property def has_field_trigger_type(self): if hasattr(self, '_m_has_field_trigger_type'): return self._m_has_field_trigger_type self._m_has_field_trigger_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_trigger_type', None) @property def has_field_filter_by_frame(self): if hasattr(self, '_m_has_field_filter_by_frame'): return self._m_has_field_filter_by_frame self._m_has_field_filter_by_frame = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_filter_by_frame', None) @property def has_field_hit_scene(self): if hasattr(self, '_m_has_field_hit_scene'): return self._m_has_field_hit_scene self._m_has_field_hit_scene = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_hit_scene', None) @property def has_field_trigger_cd(self): if hasattr(self, '_m_has_field_trigger_cd'): return self._m_has_field_trigger_cd self._m_has_field_trigger_cd = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_trigger_cd', None) @property def has_field_massive_attack_ratio(self): if hasattr(self, '_m_has_field_massive_attack_ratio'): return self._m_has_field_massive_attack_ratio self._m_has_field_massive_attack_ratio = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_massive_attack_ratio', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_born', None) class EnumDropRandomType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DropRandomType, self.data.value) return getattr(self, '_m_value', None) class EnumSceneType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneType, self.data.value) return getattr(self, '_m_value', None) class EnumQuestGuideAuto(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestGuideAuto, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumConfigPreloadTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumConfigPreloadType(self._io, self, self._root)) class HomeWorldNpcExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomRefreshExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_type: self.refresh_type = Output.EnumBlossomRefreshType(self._io, self, self._root) if self.has_field_refresh_count: self.refresh_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_time: self.refresh_time = AuxTypes.String(self._io, self, self._root) if self.has_field_open_state: self.open_state = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_open_level: self.open_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_close_level: self.close_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_cond_vec: self.refresh_cond_vec = Output.ArrayOfBlossomRefreshCondLengthS(self._io, self, self._root) if self.has_field_revise_level: self.revise_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_limit_type: self.item_limit_type = Output.EnumItemLimitType(self._io, self, self._root) if self.has_field_blossom_chest_id: self.blossom_chest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_update_need_count: self.camp_update_need_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_round_max_count: self.round_max_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_vec: self.drop_vec = Output.ArrayOfBlossomRewardExcelConfigLengthS(self._io, self, self._root) if self.has_field_client_show_type: self.client_show_type = Output.EnumBlossomShowType(self._io, self, self._root) if self.has_field_hide_bg: self.hide_bg = self._io.read_u1() if self.has_field_reward_type: self.reward_type = Output.EnumBlossomRewardType(self._io, self, self._root) @property def has_field_item_limit_type(self): if hasattr(self, '_m_has_field_item_limit_type'): return self._m_has_field_item_limit_type self._m_has_field_item_limit_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_item_limit_type', None) @property def has_field_round_max_count(self): if hasattr(self, '_m_has_field_round_max_count'): return self._m_has_field_round_max_count self._m_has_field_round_max_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_round_max_count', None) @property def has_field_drop_vec(self): if hasattr(self, '_m_has_field_drop_vec'): return self._m_has_field_drop_vec self._m_has_field_drop_vec = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_drop_vec', None) @property def has_field_hide_bg(self): if hasattr(self, '_m_has_field_hide_bg'): return self._m_has_field_hide_bg self._m_has_field_hide_bg = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_hide_bg', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_refresh_cond_vec(self): if hasattr(self, '_m_has_field_refresh_cond_vec'): return self._m_has_field_refresh_cond_vec self._m_has_field_refresh_cond_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_refresh_cond_vec', None) @property def has_field_blossom_chest_id(self): if hasattr(self, '_m_has_field_blossom_chest_id'): return self._m_has_field_blossom_chest_id self._m_has_field_blossom_chest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_blossom_chest_id', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_open_level(self): if hasattr(self, '_m_has_field_open_level'): return self._m_has_field_open_level self._m_has_field_open_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_level', None) @property def has_field_client_show_type(self): if hasattr(self, '_m_has_field_client_show_type'): return self._m_has_field_client_show_type self._m_has_field_client_show_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_client_show_type', None) @property def has_field_refresh_time(self): if hasattr(self, '_m_has_field_refresh_time'): return self._m_has_field_refresh_time self._m_has_field_refresh_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_refresh_time', None) @property def has_field_close_level(self): if hasattr(self, '_m_has_field_close_level'): return self._m_has_field_close_level self._m_has_field_close_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_close_level', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_open_state(self): if hasattr(self, '_m_has_field_open_state'): return self._m_has_field_open_state self._m_has_field_open_state = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_open_state', None) @property def has_field_camp_update_need_count(self): if hasattr(self, '_m_has_field_camp_update_need_count'): return self._m_has_field_camp_update_need_count self._m_has_field_camp_update_need_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_camp_update_need_count', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_refresh_type(self): if hasattr(self, '_m_has_field_refresh_type'): return self._m_has_field_refresh_type self._m_has_field_refresh_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_refresh_type', None) @property def has_field_refresh_count(self): if hasattr(self, '_m_has_field_refresh_count'): return self._m_has_field_refresh_count self._m_has_field_refresh_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_refresh_count', None) @property def has_field_revise_level(self): if hasattr(self, '_m_has_field_revise_level'): return self._m_has_field_revise_level self._m_has_field_revise_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_revise_level', None) @property def has_field_reward_type(self): if hasattr(self, '_m_has_field_reward_type'): return self._m_has_field_reward_type self._m_has_field_reward_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_reward_type', None) class CombineExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_combine_id: self.combine_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_player_level: self.player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_show: self.is_default_show = self._io.read_u1() if self.has_field_combine_type: self.combine_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_combine_type: self.sub_combine_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_result_item_id: self.result_item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_result_item_count: self.result_item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scoin_cost: self.scoin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_random_items: self.random_items = Output.ArrayOfRandomItemConfigLengthS(self._io, self, self._root) if self.has_field_material_items: self.material_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_effect_desc: self.effect_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recipe_type: self.recipe_type = Output.EnumRecipeType(self._io, self, self._root) @property def has_field_result_item_count(self): if hasattr(self, '_m_has_field_result_item_count'): return self._m_has_field_result_item_count self._m_has_field_result_item_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_result_item_count', None) @property def has_field_recipe_type(self): if hasattr(self, '_m_has_field_recipe_type'): return self._m_has_field_recipe_type self._m_has_field_recipe_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_recipe_type', None) @property def has_field_player_level(self): if hasattr(self, '_m_has_field_player_level'): return self._m_has_field_player_level self._m_has_field_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_player_level', None) @property def has_field_combine_type(self): if hasattr(self, '_m_has_field_combine_type'): return self._m_has_field_combine_type self._m_has_field_combine_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_combine_type', None) @property def has_field_random_items(self): if hasattr(self, '_m_has_field_random_items'): return self._m_has_field_random_items self._m_has_field_random_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_random_items', None) @property def has_field_scoin_cost(self): if hasattr(self, '_m_has_field_scoin_cost'): return self._m_has_field_scoin_cost self._m_has_field_scoin_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_scoin_cost', None) @property def has_field_is_default_show(self): if hasattr(self, '_m_has_field_is_default_show'): return self._m_has_field_is_default_show self._m_has_field_is_default_show = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_is_default_show', None) @property def has_field_effect_desc(self): if hasattr(self, '_m_has_field_effect_desc'): return self._m_has_field_effect_desc self._m_has_field_effect_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_effect_desc', None) @property def has_field_sub_combine_type(self): if hasattr(self, '_m_has_field_sub_combine_type'): return self._m_has_field_sub_combine_type self._m_has_field_sub_combine_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sub_combine_type', None) @property def has_field_result_item_id(self): if hasattr(self, '_m_has_field_result_item_id'): return self._m_has_field_result_item_id self._m_has_field_result_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_result_item_id', None) @property def has_field_material_items(self): if hasattr(self, '_m_has_field_material_items'): return self._m_has_field_material_items self._m_has_field_material_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_material_items', None) @property def has_field_combine_id(self): if hasattr(self, '_m_has_field_combine_id'): return self._m_has_field_combine_id self._m_has_field_combine_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_combine_id', None) class MiracleRingExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChangeFieldMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumChangeFieldType(self._io, self, self._root) if self.has_field_target_radius: self.target_radius = self._io.read_f4le() if self.has_field_time: self.time = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_target_radius(self): if hasattr(self, '_m_has_field_target_radius'): return self._m_has_field_target_radius self._m_has_field_target_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_radius', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HomeWorldNpcExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_i_ds: self.talk_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_npc: self.is_npc = self._io.read_u1() if self.has_field_head_icon: self.head_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_front_icon: self.front_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_side_icon: self.side_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_quality: self.quality = Output.EnumQualityType(self._io, self, self._root) if self.has_field_show_name: self.show_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_is_npc(self): if hasattr(self, '_m_has_field_is_npc'): return self._m_has_field_is_npc self._m_has_field_is_npc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_npc', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_head_icon(self): if hasattr(self, '_m_has_field_head_icon'): return self._m_has_field_head_icon self._m_has_field_head_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_head_icon', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_front_icon(self): if hasattr(self, '_m_has_field_front_icon'): return self._m_has_field_front_icon self._m_has_field_front_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_front_icon', None) @property def has_field_talk_i_ds(self): if hasattr(self, '_m_has_field_talk_i_ds'): return self._m_has_field_talk_i_ds self._m_has_field_talk_i_ds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_talk_i_ds', None) @property def has_field_side_icon(self): if hasattr(self, '_m_has_field_side_icon'): return self._m_has_field_side_icon self._m_has_field_side_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_side_icon', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_quality', None) @property def has_field_show_name(self): if hasattr(self, '_m_has_field_show_name'): return self._m_has_field_show_name self._m_has_field_show_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_show_name', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_npc_id', None) class ConfigLBaseMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_views: self.views = Output.ArrayOfDispConfigVBaseMarkLengthU(self._io, self, self._root) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_priority', None) @property def has_field_views(self): if hasattr(self, '_m_has_field_views'): return self._m_has_field_views self._m_has_field_views = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_views', None) class RegionSearchCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumAudioPlatformMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AudioPlatformMoveType, self.data.value) return getattr(self, '_m_value', None) class KillPlayEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumDialogType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DialogType, self.data.value) return getattr(self, '_m_value', None) class BartenderOrderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NarratorStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUConfigSceneMeta(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigSceneMeta(self._io, self, self._root)) class EnumMixinTargetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MixinTargetting, self.data.value) return getattr(self, '_m_value', None) class DebugLog(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_content: self.content = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_content', None) class QuestSpecialShowConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReliquaryMainPropExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireworksFactorExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SectrStreamObjectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEffigyCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EffigyCondition, self.data.value) return getattr(self, '_m_value', None) class ConfigParabolaBulletMoveCorrection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMoveCorrection(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_deviation: self.deviation = self._io.read_f4le() if self.has_field_fix_angle_of_ver: self.fix_angle_of_ver = self._io.read_f4le() if self.has_field_min_speed: self.min_speed = self._io.read_f4le() if self.has_field_max_speed: self.max_speed = self._io.read_f4le() @property def has_field_deviation(self): if hasattr(self, '_m_has_field_deviation'): return self._m_has_field_deviation self._m_has_field_deviation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_deviation', None) @property def has_field_fix_angle_of_ver(self): if hasattr(self, '_m_has_field_fix_angle_of_ver'): return self._m_has_field_fix_angle_of_ver self._m_has_field_fix_angle_of_ver = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fix_angle_of_ver', None) @property def has_field_min_speed(self): if hasattr(self, '_m_has_field_min_speed'): return self._m_has_field_min_speed self._m_has_field_min_speed = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_speed', None) @property def has_field_max_speed(self): if hasattr(self, '_m_has_field_max_speed'): return self._m_has_field_max_speed self._m_has_field_max_speed = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_speed', None) class SelectTargetDefaultTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ModifierWithPredicates(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_attach_modifier: self.attach_modifier = self._io.read_u1() @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_attach_modifier(self): if hasattr(self, '_m_has_field_attach_modifier'): return self._m_has_field_attach_modifier self._m_has_field_attach_modifier = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attach_modifier', None) class ActivityMistTrialLevelFactorExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChangeUgcRayTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ray_tag: self.ray_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_ray_tag(self): if hasattr(self, '_m_has_field_ray_tag'): return self._m_has_field_ray_tag self._m_has_field_ray_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ray_tag', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumStrengthenDungeonType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.StrengthenDungeonType, self.data.value) return getattr(self, '_m_value', None) class GlobalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) class KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialProbeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSpacialProbeData(self._io, self, self._root) class DraftInviteTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LevelBuffSpecialComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MechanicusDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_list: self.dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_coin_rate: self.coin_rate = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_build_gear_limit: self.build_gear_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_coin_rate(self): if hasattr(self, '_m_has_field_coin_rate'): return self._m_has_field_coin_rate self._m_has_field_coin_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_coin_rate', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_dungeon_list(self): if hasattr(self, '_m_has_field_dungeon_list'): return self._m_has_field_dungeon_list self._m_has_field_dungeon_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_list', None) @property def has_field_build_gear_limit(self): if hasattr(self, '_m_has_field_build_gear_limit'): return self._m_has_field_build_gear_limit self._m_has_field_build_gear_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_build_gear_limit', None) class ArrayOfDispConfigCameraSplineBasePointLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigCameraSplineBasePoint(self._io, self, self._root)) class DictOfEnumEFootprintPlatformConfigFootprintEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumEFootprintPlatformConfigFootprintEffect(self._io, self, self._root)) class PositionModifyStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IssueCommand(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_command_id: self.command_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_duration: self.duration = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_command_id(self): if hasattr(self, '_m_has_field_command_id'): return self._m_has_field_command_id self._m_has_field_command_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_command_id', None) class MpPlayAbilityGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CollisionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_collision: self.collision = Output.ConfigCollision(self._io, self, self._root) if self.has_field_min_shock_speed: self.min_shock_speed = self._io.read_f4le() if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_on_collision: self.on_collision = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_min_shock_speed(self): if hasattr(self, '_m_has_field_min_shock_speed'): return self._m_has_field_min_shock_speed self._m_has_field_min_shock_speed = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_shock_speed', None) @property def has_field_on_collision(self): if hasattr(self, '_m_has_field_on_collision'): return self._m_has_field_on_collision self._m_has_field_on_collision = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_on_collision', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_collision(self): if hasattr(self, '_m_has_field_collision'): return self._m_has_field_collision self._m_has_field_collision = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_collision', None) class GetTeamTotalMaxEnergyToOverridemap(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_team_type: self.team_type = Output.EnumTeamType(self._io, self, self._root) if self.has_field_override_map_key: self.override_map_key = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_override_map_key(self): if hasattr(self, '_m_has_field_override_map_key'): return self._m_has_field_override_map_key self._m_has_field_override_map_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_override_map_key', None) @property def has_field_team_type(self): if hasattr(self, '_m_has_field_team_type'): return self._m_has_field_team_type self._m_has_field_team_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_team_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class VegetationInteractTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductMcoinDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnvAnimalWeightExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestGuideType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestGuideType, self.data.value) return getattr(self, '_m_value', None) class ConfigAttackTargetMapEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attack_pattern: self.attack_pattern = Output.DispConfigBaseAttackPattern(self._io, self, self._root) if self.has_field_attack_info_map: self.attack_info_map = Output.DictOfEnumTargetTypeConfigAttackInfo(self._io, self, self._root) @property def has_field_attack_pattern(self): if hasattr(self, '_m_has_field_attack_pattern'): return self._m_has_field_attack_pattern self._m_has_field_attack_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_pattern', None) @property def has_field_attack_info_map(self): if hasattr(self, '_m_has_field_attack_info_map'): return self._m_has_field_attack_info_map self._m_has_field_attack_info_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attack_info_map', None) class InvestigationDungeonConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMechanicusCardTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MechanicusCardTargetType, self.data.value) return getattr(self, '_m_value', None) class PlayerDieTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfRogueDiaryRoundExcelConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RogueDiaryRoundExcelConfig(self._io, self, self._root)) class DailyTaskAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_cond_type: self.cond_type = Output.EnumDailyTaskCondType(self._io, self, self._root) if self.has_field_cond_param1: self.cond_param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_cond_param2: self.cond_param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_cond_param3: self.cond_param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDailyTaskActionType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_param3', None) @property def has_field_cond_param1(self): if hasattr(self, '_m_has_field_cond_param1'): return self._m_has_field_cond_param1 self._m_has_field_cond_param1 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cond_param1', None) @property def has_field_cond_param3(self): if hasattr(self, '_m_has_field_cond_param3'): return self._m_has_field_cond_param3 self._m_has_field_cond_param3 = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cond_param3', None) @property def has_field_cond_param2(self): if hasattr(self, '_m_has_field_cond_param2'): return self._m_has_field_cond_param2 self._m_has_field_cond_param2 = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cond_param2', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_param2', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_param1', None) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cond_type', None) class EnumChannellerSlabBuffQuality(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChannellerSlabBuffQuality, self.data.value) return getattr(self, '_m_value', None) class TrialAvatarFetterDataConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_cond: self.finish_cond = Output.TrialFetterConditionConfig(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_finish_cond(self): if hasattr(self, '_m_has_field_finish_cond'): return self._m_has_field_finish_cond self._m_has_field_finish_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_finish_cond', None) class ChannellerSlabBuffEnergyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LimitRegionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_openstate: self.openstate = Output.EnumOpenStateType(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumLimitRegionType(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_openstate(self): if hasattr(self, '_m_has_field_openstate'): return self._m_has_field_openstate self._m_has_field_openstate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_openstate', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_order', None) class ConfigAiNerveTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NpcBodyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfGradeItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfGradeItem(self._io, self, self._root)) class AiLodStrategyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicTransitions(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_shifters: self.shifters = Output.ArrayOfConfigMusicShifterLengthU(self._io, self, self._root) @property def has_field_shifters(self): if hasattr(self, '_m_has_field_shifters'): return self._m_has_field_shifters self._m_has_field_shifters = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shifters', None) class ChangeGadgetUiInteractHint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hint_text_map_id: self.hint_text_map_id = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_hint_text_map_id(self): if hasattr(self, '_m_has_field_hint_text_map_id'): return self._m_has_field_hint_text_map_id self._m_has_field_hint_text_map_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hint_text_map_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigAiFacingMoveWeight(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_stop: self.stop = self._io.read_f4le() if self.has_field_forward: self.forward = self._io.read_f4le() if self.has_field_back: self.back = self._io.read_f4le() if self.has_field_left: self.left = self._io.read_f4le() if self.has_field_right: self.right = self._io.read_f4le() @property def has_field_forward(self): if hasattr(self, '_m_has_field_forward'): return self._m_has_field_forward self._m_has_field_forward = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_forward', None) @property def has_field_right(self): if hasattr(self, '_m_has_field_right'): return self._m_has_field_right self._m_has_field_right = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_right', None) @property def has_field_back(self): if hasattr(self, '_m_has_field_back'): return self._m_has_field_back self._m_has_field_back = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_back', None) @property def has_field_left(self): if hasattr(self, '_m_has_field_left'): return self._m_has_field_left self._m_has_field_left = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_left', None) @property def has_field_stop(self): if hasattr(self, '_m_has_field_stop'): return self._m_has_field_stop self._m_has_field_stop = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stop', None) class PlaceNameConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_map_tag_type: self.map_tag_type = Output.EnumMapTagType(self._io, self, self._root) if self.has_field_place_name_id: self.place_name_id = AuxTypes.String(self._io, self, self._root) if self.has_field_condition_type: self.condition_type = Output.EnumPlaceNameConditionType(self._io, self, self._root) if self.has_field_condition_param1: self.condition_param1 = AuxTypes.String(self._io, self, self._root) if self.has_field_condition_param2: self.condition_param2 = AuxTypes.String(self._io, self, self._root) if self.has_field_action_type: self.action_type = Output.EnumPlaceNameActionType(self._io, self, self._root) @property def has_field_condition_type(self): if hasattr(self, '_m_has_field_condition_type'): return self._m_has_field_condition_type self._m_has_field_condition_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_condition_type', None) @property def has_field_condition_param2(self): if hasattr(self, '_m_has_field_condition_param2'): return self._m_has_field_condition_param2 self._m_has_field_condition_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_condition_param2', None) @property def has_field_action_type(self): if hasattr(self, '_m_has_field_action_type'): return self._m_has_field_action_type self._m_has_field_action_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_action_type', None) @property def has_field_condition_param1(self): if hasattr(self, '_m_has_field_condition_param1'): return self._m_has_field_condition_param1 self._m_has_field_condition_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_condition_param1', None) @property def has_field_map_tag_type(self): if hasattr(self, '_m_has_field_map_tag_type'): return self._m_has_field_map_tag_type self._m_has_field_map_tag_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_map_tag_type', None) @property def has_field_place_name_id(self): if hasattr(self, '_m_has_field_place_name_id'): return self._m_has_field_place_name_id self._m_has_field_place_name_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_place_name_id', None) class EnumPickType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PickType, self.data.value) return getattr(self, '_m_value', None) class EnumBonusActivityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BonusActivityType, self.data.value) return getattr(self, '_m_value', None) class ReminderIndexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ControlPartRotateByComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ButtonGuideTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigComprehensiveQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_local_lighting_shadow: self.local_lighting_shadow = self._io.read_u1() if self.has_field_terrain_blend_distance: self.terrain_blend_distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shader_lod_distance: self.shader_lod_distance = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shader_quality_keyword: self.shader_quality_keyword = AuxTypes.String(self._io, self, self._root) if self.has_field_level_streaming_config: self.level_streaming_config = AuxTypes.String(self._io, self, self._root) if self.has_field_enviro_config: self.enviro_config = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_cache_config: self.ui_cache_config = AuxTypes.String(self._io, self, self._root) if self.has_field_light_view_distance_ratio: self.light_view_distance_ratio = self._io.read_f4le() if self.has_field_grass_quality: self.grass_quality = Output.EnumGrassQualityLevel(self._io, self, self._root) if self.has_field_light_on_level: self.light_on_level = Output.EnumLightLevel(self._io, self, self._root) if self.has_field_entity_lod_config: self.entity_lod_config = AuxTypes.String(self._io, self, self._root) if self.has_field_enable_remote_avatar_lod: self.enable_remote_avatar_lod = self._io.read_u1() if self.has_field_enable_dynamic_light: self.enable_dynamic_light = self._io.read_u1() if self.has_field_fade_tint_distance: self.fade_tint_distance = self._io.read_f4le() if self.has_field_fade_tint_size: self.fade_tint_size = self._io.read_f4le() if self.has_field_texture_streaming_budget: self.texture_streaming_budget = self._io.read_f4le() if self.has_field_fade_tint_quality: self.fade_tint_quality = Output.EnumFadeTintQualityLevel(self._io, self, self._root) if self.has_field_terrain_distance: self.terrain_distance = self._io.read_f4le() if self.has_field_terrain_normal: self.terrain_normal = self._io.read_f4le() if self.has_field_shell_count: self.shell_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_shell_max_objects_count: self.shell_max_objects_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_use_crowd_cone_view_optim: self.use_crowd_cone_view_optim = self._io.read_u1() if self.has_field_crowd_max_screen_num: self.crowd_max_screen_num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_crowd_cone_view_update_period: self.crowd_cone_view_update_period = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_terrain_distance(self): if hasattr(self, '_m_has_field_terrain_distance'): return self._m_has_field_terrain_distance self._m_has_field_terrain_distance = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_terrain_distance', None) @property def has_field_enable_dynamic_light(self): if hasattr(self, '_m_has_field_enable_dynamic_light'): return self._m_has_field_enable_dynamic_light self._m_has_field_enable_dynamic_light = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_enable_dynamic_light', None) @property def has_field_light_on_level(self): if hasattr(self, '_m_has_field_light_on_level'): return self._m_has_field_light_on_level self._m_has_field_light_on_level = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_light_on_level', None) @property def has_field_enviro_config(self): if hasattr(self, '_m_has_field_enviro_config'): return self._m_has_field_enviro_config self._m_has_field_enviro_config = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_enviro_config', None) @property def has_field_enable_remote_avatar_lod(self): if hasattr(self, '_m_has_field_enable_remote_avatar_lod'): return self._m_has_field_enable_remote_avatar_lod self._m_has_field_enable_remote_avatar_lod = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_enable_remote_avatar_lod', None) @property def has_field_crowd_cone_view_update_period(self): if hasattr(self, '_m_has_field_crowd_cone_view_update_period'): return self._m_has_field_crowd_cone_view_update_period self._m_has_field_crowd_cone_view_update_period = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_crowd_cone_view_update_period', None) @property def has_field_texture_streaming_budget(self): if hasattr(self, '_m_has_field_texture_streaming_budget'): return self._m_has_field_texture_streaming_budget self._m_has_field_texture_streaming_budget = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_texture_streaming_budget', None) @property def has_field_entity_lod_config(self): if hasattr(self, '_m_has_field_entity_lod_config'): return self._m_has_field_entity_lod_config self._m_has_field_entity_lod_config = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_entity_lod_config', None) @property def has_field_light_view_distance_ratio(self): if hasattr(self, '_m_has_field_light_view_distance_ratio'): return self._m_has_field_light_view_distance_ratio self._m_has_field_light_view_distance_ratio = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_light_view_distance_ratio', None) @property def has_field_fade_tint_distance(self): if hasattr(self, '_m_has_field_fade_tint_distance'): return self._m_has_field_fade_tint_distance self._m_has_field_fade_tint_distance = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_fade_tint_distance', None) @property def has_field_fade_tint_quality(self): if hasattr(self, '_m_has_field_fade_tint_quality'): return self._m_has_field_fade_tint_quality self._m_has_field_fade_tint_quality = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_fade_tint_quality', None) @property def has_field_shell_count(self): if hasattr(self, '_m_has_field_shell_count'): return self._m_has_field_shell_count self._m_has_field_shell_count = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_shell_count', None) @property def has_field_grass_quality(self): if hasattr(self, '_m_has_field_grass_quality'): return self._m_has_field_grass_quality self._m_has_field_grass_quality = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_grass_quality', None) @property def has_field_crowd_max_screen_num(self): if hasattr(self, '_m_has_field_crowd_max_screen_num'): return self._m_has_field_crowd_max_screen_num self._m_has_field_crowd_max_screen_num = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_crowd_max_screen_num', None) @property def has_field_shader_quality_keyword(self): if hasattr(self, '_m_has_field_shader_quality_keyword'): return self._m_has_field_shader_quality_keyword self._m_has_field_shader_quality_keyword = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_shader_quality_keyword', None) @property def has_field_local_lighting_shadow(self): if hasattr(self, '_m_has_field_local_lighting_shadow'): return self._m_has_field_local_lighting_shadow self._m_has_field_local_lighting_shadow = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_local_lighting_shadow', None) @property def has_field_shell_max_objects_count(self): if hasattr(self, '_m_has_field_shell_max_objects_count'): return self._m_has_field_shell_max_objects_count self._m_has_field_shell_max_objects_count = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_shell_max_objects_count', None) @property def has_field_terrain_normal(self): if hasattr(self, '_m_has_field_terrain_normal'): return self._m_has_field_terrain_normal self._m_has_field_terrain_normal = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_terrain_normal', None) @property def has_field_shader_lod_distance(self): if hasattr(self, '_m_has_field_shader_lod_distance'): return self._m_has_field_shader_lod_distance self._m_has_field_shader_lod_distance = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_shader_lod_distance', None) @property def has_field_ui_cache_config(self): if hasattr(self, '_m_has_field_ui_cache_config'): return self._m_has_field_ui_cache_config self._m_has_field_ui_cache_config = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_ui_cache_config', None) @property def has_field_fade_tint_size(self): if hasattr(self, '_m_has_field_fade_tint_size'): return self._m_has_field_fade_tint_size self._m_has_field_fade_tint_size = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_fade_tint_size', None) @property def has_field_level_streaming_config(self): if hasattr(self, '_m_has_field_level_streaming_config'): return self._m_has_field_level_streaming_config self._m_has_field_level_streaming_config = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_level_streaming_config', None) @property def has_field_use_crowd_cone_view_optim(self): if hasattr(self, '_m_has_field_use_crowd_cone_view_optim'): return self._m_has_field_use_crowd_cone_view_optim self._m_has_field_use_crowd_cone_view_optim = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_use_crowd_cone_view_optim', None) @property def has_field_terrain_blend_distance(self): if hasattr(self, '_m_has_field_terrain_blend_distance'): return self._m_has_field_terrain_blend_distance self._m_has_field_terrain_blend_distance = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_terrain_blend_distance', None) class AvatarCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_factor: self.sort_factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_time: self.begin_time = AuxTypes.String(self._io, self, self._root) if self.has_field_hide_when_dont_have: self.hide_when_dont_have = self._io.read_u1() @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sort_id', None) @property def has_field_sort_factor(self): if hasattr(self, '_m_has_field_sort_factor'): return self._m_has_field_sort_factor self._m_has_field_sort_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sort_factor', None) @property def has_field_hide_when_dont_have(self): if hasattr(self, '_m_has_field_hide_when_dont_have'): return self._m_has_field_hide_when_dont_have self._m_has_field_hide_when_dont_have = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_hide_when_dont_have', None) @property def has_field_begin_time(self): if hasattr(self, '_m_has_field_begin_time'): return self._m_has_field_begin_time self._m_has_field_begin_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_begin_time', None) class MichiaeWatcherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name_hash: self.icon_name_hash_pre = self._io.read_s1() @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_icon_name_hash(self): if hasattr(self, '_m_has_field_icon_name_hash'): return self._m_has_field_icon_name_hash self._m_has_field_icon_name_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon_name_hash', None) class ConfigAttackInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attack_tag: self.attack_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_attenuation_tag: self.attenuation_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_attenuation_group: self.attenuation_group = AuxTypes.String(self._io, self, self._root) if self.has_field_sus: self.sus = self._io.read_u1() if self.has_field_attack_property: self.attack_property = Output.ConfigAttackProperty(self._io, self, self._root) if self.has_field_hit_pattern: self.hit_pattern = Output.ConfigHitPattern(self._io, self, self._root) if self.has_field_can_hit_head: self.can_hit_head = self._io.read_u1() if self.has_field_hit_head_pattern: self.hit_head_pattern = Output.ConfigHitPattern(self._io, self, self._root) if self.has_field_force_camera_shake: self.force_camera_shake = self._io.read_u1() if self.has_field_camera_shake: self.camera_shake = Output.ConfigCameraShake(self._io, self, self._root) if self.has_field_bullet_wane: self.bullet_wane = Output.ConfigBulletWane(self._io, self, self._root) if self.has_field_can_be_modified_by: self.can_be_modified_by = Output.EnumCanBeModifiedBy(self._io, self, self._root) @property def has_field_can_hit_head(self): if hasattr(self, '_m_has_field_can_hit_head'): return self._m_has_field_can_hit_head self._m_has_field_can_hit_head = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_can_hit_head', None) @property def has_field_attenuation_tag(self): if hasattr(self, '_m_has_field_attenuation_tag'): return self._m_has_field_attenuation_tag self._m_has_field_attenuation_tag = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_attenuation_tag', None) @property def has_field_attack_property(self): if hasattr(self, '_m_has_field_attack_property'): return self._m_has_field_attack_property self._m_has_field_attack_property = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_attack_property', None) @property def has_field_bullet_wane(self): if hasattr(self, '_m_has_field_bullet_wane'): return self._m_has_field_bullet_wane self._m_has_field_bullet_wane = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_bullet_wane', None) @property def has_field_sus(self): if hasattr(self, '_m_has_field_sus'): return self._m_has_field_sus self._m_has_field_sus = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_sus', None) @property def has_field_attenuation_group(self): if hasattr(self, '_m_has_field_attenuation_group'): return self._m_has_field_attenuation_group self._m_has_field_attenuation_group = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_attenuation_group', None) @property def has_field_hit_head_pattern(self): if hasattr(self, '_m_has_field_hit_head_pattern'): return self._m_has_field_hit_head_pattern self._m_has_field_hit_head_pattern = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_hit_head_pattern', None) @property def has_field_can_be_modified_by(self): if hasattr(self, '_m_has_field_can_be_modified_by'): return self._m_has_field_can_be_modified_by self._m_has_field_can_be_modified_by = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_can_be_modified_by', None) @property def has_field_camera_shake(self): if hasattr(self, '_m_has_field_camera_shake'): return self._m_has_field_camera_shake self._m_has_field_camera_shake = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_camera_shake', None) @property def has_field_attack_tag(self): if hasattr(self, '_m_has_field_attack_tag'): return self._m_has_field_attack_tag self._m_has_field_attack_tag = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_attack_tag', None) @property def has_field_force_camera_shake(self): if hasattr(self, '_m_has_field_force_camera_shake'): return self._m_has_field_force_camera_shake self._m_has_field_force_camera_shake = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_force_camera_shake', None) @property def has_field_hit_pattern(self): if hasattr(self, '_m_has_field_hit_pattern'): return self._m_has_field_hit_pattern self._m_has_field_hit_pattern = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_hit_pattern', None) class TriggerAuxWeaponTrans(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_enable: self.set_enable = self._io.read_u1() if self.has_field_equip_part: self.equip_part = AuxTypes.String(self._io, self, self._root) @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_equip_part(self): if hasattr(self, '_m_has_field_equip_part'): return self._m_has_field_equip_part self._m_has_field_equip_part = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_equip_part', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RogueSequenceCellConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRogueCellType(self._io, self, self._root) if self.has_field_range: self.range = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_range', None) class ArrayOfDispConfigMusicStimulusHandlerLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigMusicStimulusHandler(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeSConfigAiScriptedMoveToData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiScriptedMoveToData(self._io, self, self._root)) class ContextConditionMainQuestState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state: self.state = Output.EnumQuestState(self._io, self, self._root) @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_state(self): if hasattr(self, '_m_has_field_state'): return self._m_has_field_state self._m_has_field_state = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state', None) class UgcFormulaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicInt32inequalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class HomeWorldAreaComfortExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfQuestExecLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.QuestExec(self._io, self, self._root)) class RefreshIndexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPotionLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_count_limit: self.buff_count_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_preview: self.monster_preview = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_medal_score_list: self.medal_score_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_medal_time_list_normal: self.medal_time_list_normal = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_medal_time_list_hard: self.medal_time_list_hard = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_medal_time_list_hard(self): if hasattr(self, '_m_has_field_medal_time_list_hard'): return self._m_has_field_medal_time_list_hard self._m_has_field_medal_time_list_hard = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_medal_time_list_hard', None) @property def has_field_medal_time_list_normal(self): if hasattr(self, '_m_has_field_medal_time_list_normal'): return self._m_has_field_medal_time_list_normal self._m_has_field_medal_time_list_normal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_medal_time_list_normal', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_medal_score_list(self): if hasattr(self, '_m_has_field_medal_score_list'): return self._m_has_field_medal_score_list self._m_has_field_medal_score_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_medal_score_list', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_buff_count_limit(self): if hasattr(self, '_m_has_field_buff_count_limit'): return self._m_has_field_buff_count_limit self._m_has_field_buff_count_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_buff_count_limit', None) @property def has_field_monster_preview(self): if hasattr(self, '_m_has_field_monster_preview'): return self._m_has_field_monster_preview self._m_has_field_monster_preview = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_monster_preview', None) class EnumArithType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ArithType, self.data.value) return getattr(self, '_m_value', None) class EnumShowQuestGuideType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShowQuestGuideType, self.data.value) return getattr(self, '_m_value', None) class TemplateParamInt32(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.TemplateParam(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_origin_value: self.origin_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_origin_value(self): if hasattr(self, '_m_has_field_origin_value'): return self._m_has_field_origin_value self._m_has_field_origin_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_origin_value', None) @property def param(self): if hasattr(self, '_m_param'): return self._m_param self._m_param = self.base.param return getattr(self, '_m_param', None) class VehicleMarkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumEquipType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EquipType, self.data.value) return getattr(self, '_m_value', None) class EmojiDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_set_id: self.set_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_set_id(self): if hasattr(self, '_m_has_field_set_id'): return self._m_has_field_set_id self._m_has_field_set_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_set_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_content', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_order', None) class LimitRegionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGrassQualityLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GrassQualityLevel, self.data.value) return getattr(self, '_m_value', None) class EnumIrodoriChessCardTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriChessCardTag, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringDispConfigSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigSpecialCamera(self._io, self, self._root)) class ConfigEquipReattach(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_equip: self.equip = AuxTypes.String(self._io, self, self._root) if self.has_field_target_point: self.target_point = AuxTypes.String(self._io, self, self._root) if self.has_field_normalize_start: self.normalize_start = self._io.read_f4le() if self.has_field_normalize_end: self.normalize_end = self._io.read_f4le() @property def has_field_equip(self): if hasattr(self, '_m_has_field_equip'): return self._m_has_field_equip self._m_has_field_equip = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_equip', None) @property def has_field_target_point(self): if hasattr(self, '_m_has_field_target_point'): return self._m_has_field_target_point self._m_has_field_target_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_point', None) @property def has_field_normalize_start(self): if hasattr(self, '_m_has_field_normalize_start'): return self._m_has_field_normalize_start self._m_has_field_normalize_start = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_normalize_start', None) @property def has_field_normalize_end(self): if hasattr(self, '_m_has_field_normalize_end'): return self._m_has_field_normalize_end self._m_has_field_normalize_end = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_normalize_end', None) class ConfigHomeworldFurnitureLightComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_light_range: self.light_range = self._io.read_f4le() if self.has_field_light_intensity: self.light_intensity = self._io.read_f4le() if self.has_field_min_view_dist_ratio: self.min_view_dist_ratio = self._io.read_f4le() if self.has_field_max_view_dist_ratio: self.max_view_dist_ratio = self._io.read_f4le() if self.has_field_light_type: self.light_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lightmap_bake_type: self.lightmap_bake_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_light_shading_mode: self.light_shading_mode = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_light_color: self.light_color = Output.ColorVector(self._io, self, self._root) if self.has_field_light_hsv: self.light_hsv = Output.Vector(self._io, self, self._root) @property def has_field_light_shading_mode(self): if hasattr(self, '_m_has_field_light_shading_mode'): return self._m_has_field_light_shading_mode self._m_has_field_light_shading_mode = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_light_shading_mode', None) @property def has_field_light_color(self): if hasattr(self, '_m_has_field_light_color'): return self._m_has_field_light_color self._m_has_field_light_color = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_light_color', None) @property def has_field_light_intensity(self): if hasattr(self, '_m_has_field_light_intensity'): return self._m_has_field_light_intensity self._m_has_field_light_intensity = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_light_intensity', None) @property def has_field_max_view_dist_ratio(self): if hasattr(self, '_m_has_field_max_view_dist_ratio'): return self._m_has_field_max_view_dist_ratio self._m_has_field_max_view_dist_ratio = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_max_view_dist_ratio', None) @property def has_field_light_type(self): if hasattr(self, '_m_has_field_light_type'): return self._m_has_field_light_type self._m_has_field_light_type = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_light_type', None) @property def has_field_lightmap_bake_type(self): if hasattr(self, '_m_has_field_lightmap_bake_type'): return self._m_has_field_lightmap_bake_type self._m_has_field_lightmap_bake_type = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_lightmap_bake_type', None) @property def has_field_light_range(self): if hasattr(self, '_m_has_field_light_range'): return self._m_has_field_light_range self._m_has_field_light_range = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_light_range', None) @property def has_field_light_hsv(self): if hasattr(self, '_m_has_field_light_hsv'): return self._m_has_field_light_hsv self._m_has_field_light_hsv = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_light_hsv', None) @property def has_field_min_view_dist_ratio(self): if hasattr(self, '_m_has_field_min_view_dist_ratio'): return self._m_has_field_min_view_dist_ratio self._m_has_field_min_view_dist_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_min_view_dist_ratio', None) class KvpOfDictAuxTypesStringConfigLoadingDoor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigLoadingDoor(self._io, self, self._root) class AudioScopeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiFishingPretendBitesData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiFishingPretendBitesData(self._io, self, self._root) class ConfigWindmillMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class RogueGadgetRotConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dir: self.dir = Output.EnumRogueGadgetDirType(self._io, self, self._root) if self.has_field_rotation: self.rotation = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_dir(self): if hasattr(self, '_m_has_field_dir'): return self._m_has_field_dir self._m_has_field_dir = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dir', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rotation', None) class EnumSalesmanSpecialRewardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SalesmanSpecialRewardType, self.data.value) return getattr(self, '_m_value', None) class AiBitsFlag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAvatarCanShakeOff(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_can_shake_off: self.can_shake_off = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_can_shake_off(self): if hasattr(self, '_m_has_field_can_shake_off'): return self._m_has_field_can_shake_off self._m_has_field_can_shake_off = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_can_shake_off', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumHasShieldType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HasShieldType, self.data.value) return getattr(self, '_m_value', None) class GroupTagExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag_name: self.tag_name = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_tag_name(self): if hasattr(self, '_m_has_field_tag_name'): return self._m_has_field_tag_name self._m_has_field_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tag_name', None) class KvpOfDictAuxTypesVlqBase128LeUDispConfigBaseWidgetToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.DispConfigBaseWidgetToy(self._io, self, self._root) class RoguelikeCardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TextMapConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) class ConfigSkinFashionEffects(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_old_effects: self.old_effects = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_new_effects: self.new_effects = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_old_effects(self): if hasattr(self, '_m_has_field_old_effects'): return self._m_has_field_old_effects self._m_has_field_old_effects = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_old_effects', None) @property def has_field_new_effects(self): if hasattr(self, '_m_has_field_new_effects'): return self._m_has_field_new_effects self._m_has_field_new_effects = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_new_effects', None) class EnumMpPlayShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MpPlayShowType, self.data.value) return getattr(self, '_m_value', None) class GadgetUiItemGroupShowCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGraphicSettingEntrySortTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumFireworksLaunchParamType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FireworksLaunchParamType, self.data.value) return getattr(self, '_m_value', None) class ConfigSgvRegister(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sgv_list: self.sgv_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_sgv_list(self): if hasattr(self, '_m_has_field_sgv_list'): return self._m_has_field_sgv_list self._m_has_field_sgv_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sgv_list', None) class ConfigBornByRushToPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class AvatarExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_use_type: self.use_type = Output.EnumAvatarUseType(self._io, self, self._root) if self.has_field_body_type: self.body_type = Output.EnumBodyType(self._io, self, self._root) if self.has_field_script_data_path_hash: self.script_data_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_side_icon_name: self.side_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_quality_type: self.quality_type = Output.EnumQualityType(self._io, self, self._root) if self.has_field_charge_efficiency: self.charge_efficiency = self._io.read_f4le() if self.has_field_heal_add: self.heal_add = self._io.read_f4le() if self.has_field_healed_add: self.healed_add = self._io.read_f4le() if self.has_field_combat_config_hash: self.combat_config_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_range_attack: self.is_range_attack = self._io.read_u1() if self.has_field_initial_weapon: self.initial_weapon = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weapon_type: self.weapon_type = Output.EnumWeaponType(self._io, self, self._root) if self.has_field_manekin_path_hash: self.manekin_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_image_name: self.image_name = AuxTypes.String(self._io, self, self._root) if self.has_field_gacha_card_name_hash: self.gacha_card_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gacha_image_name_hash: self.gacha_image_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_pic_name_hash: self.coop_pic_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cutscene_show: self.cutscene_show = AuxTypes.String(self._io, self, self._root) if self.has_field_skill_depot_id: self.skill_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stamina_recover_speed: self.stamina_recover_speed = self._io.read_f4le() if self.has_field_cand_skill_depot_ids: self.cand_skill_depot_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_manekin_json_config_hash: self.manekin_json_config_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_manekin_motion_config: self.manekin_motion_config = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_identity_type: self.avatar_identity_type = Output.EnumAvatarIdentityType(self._io, self, self._root) if self.has_field_avatar_promote_id: self.avatar_promote_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_promote_reward_level_list: self.avatar_promote_reward_level_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_promote_reward_id_list: self.avatar_promote_reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_feature_tag_group_id: self.feature_tag_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_info_desc: self.info_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sus: self.sus = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hp_base: self.hp_base = self._io.read_f4le() if self.has_field_attack_base: self.attack_base = self._io.read_f4le() if self.has_field_defense_base: self.defense_base = self._io.read_f4le() if self.has_field_critical: self.critical = self._io.read_f4le() if self.has_field_anti_critical: self.anti_critical = self._io.read_f4le() if self.has_field_critical_hurt: self.critical_hurt = self._io.read_f4le() if self.has_field_fire_sub_hurt: self.fire_sub_hurt = self._io.read_f4le() if self.has_field_grass_sub_hurt: self.grass_sub_hurt = self._io.read_f4le() if self.has_field_water_sub_hurt: self.water_sub_hurt = self._io.read_f4le() if self.has_field_elec_sub_hurt: self.elec_sub_hurt = self._io.read_f4le() if self.has_field_wind_sub_hurt: self.wind_sub_hurt = self._io.read_f4le() if self.has_field_ice_sub_hurt: self.ice_sub_hurt = self._io.read_f4le() if self.has_field_rock_sub_hurt: self.rock_sub_hurt = self._io.read_f4le() if self.has_field_fire_add_hurt: self.fire_add_hurt = self._io.read_f4le() if self.has_field_grass_add_hurt: self.grass_add_hurt = self._io.read_f4le() if self.has_field_water_add_hurt: self.water_add_hurt = self._io.read_f4le() if self.has_field_elec_add_hurt: self.elec_add_hurt = self._io.read_f4le() if self.has_field_wind_add_hurt: self.wind_add_hurt = self._io.read_f4le() if self.has_field_ice_add_hurt: self.ice_add_hurt = self._io.read_f4le() if self.has_field_rock_add_hurt: self.rock_add_hurt = self._io.read_f4le() if self.has_field_prop_grow_curves: self.prop_grow_curves = Output.ArrayOfFightPropGrowConfigLengthS(self._io, self, self._root) if self.has_field_element_mastery: self.element_mastery = self._io.read_f4le() if self.has_field_physical_sub_hurt: self.physical_sub_hurt = self._io.read_f4le() if self.has_field_physical_add_hurt: self.physical_add_hurt = self._io.read_f4le() self.sus2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_ragdoll_hash: self.prefab_path_ragdoll_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_manekin_json_config_hash(self): if hasattr(self, '_m_has_field_manekin_json_config_hash'): return self._m_has_field_manekin_json_config_hash self._m_has_field_manekin_json_config_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_manekin_json_config_hash', None) @property def has_field_stamina_recover_speed(self): if hasattr(self, '_m_has_field_stamina_recover_speed'): return self._m_has_field_stamina_recover_speed self._m_has_field_stamina_recover_speed = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_stamina_recover_speed', None) @property def has_field_healed_add(self): if hasattr(self, '_m_has_field_healed_add'): return self._m_has_field_healed_add self._m_has_field_healed_add = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_healed_add', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_critical(self): if hasattr(self, '_m_has_field_critical'): return self._m_has_field_critical self._m_has_field_critical = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 16) != 0)) return getattr(self, '_m_has_field_critical', None) @property def has_field_rock_add_hurt(self): if hasattr(self, '_m_has_field_rock_add_hurt'): return self._m_has_field_rock_add_hurt self._m_has_field_rock_add_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 16) != 0)) return getattr(self, '_m_has_field_rock_add_hurt', None) @property def has_field_heal_add(self): if hasattr(self, '_m_has_field_heal_add'): return self._m_has_field_heal_add self._m_has_field_heal_add = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_heal_add', None) @property def has_field_fire_sub_hurt(self): if hasattr(self, '_m_has_field_fire_sub_hurt'): return self._m_has_field_fire_sub_hurt self._m_has_field_fire_sub_hurt = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 128) != 0)) return getattr(self, '_m_has_field_fire_sub_hurt', None) @property def has_field_manekin_path_hash(self): if hasattr(self, '_m_has_field_manekin_path_hash'): return self._m_has_field_manekin_path_hash self._m_has_field_manekin_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_manekin_path_hash', None) @property def has_field_physical_sub_hurt(self): if hasattr(self, '_m_has_field_physical_sub_hurt'): return self._m_has_field_physical_sub_hurt self._m_has_field_physical_sub_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 128) != 0)) return getattr(self, '_m_has_field_physical_sub_hurt', None) @property def has_field_attack_base(self): if hasattr(self, '_m_has_field_attack_base'): return self._m_has_field_attack_base self._m_has_field_attack_base = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 4) != 0)) return getattr(self, '_m_has_field_attack_base', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 16) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 8) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_skill_depot_id(self): if hasattr(self, '_m_has_field_skill_depot_id'): return self._m_has_field_skill_depot_id self._m_has_field_skill_depot_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_skill_depot_id', None) @property def has_field_hp_base(self): if hasattr(self, '_m_has_field_hp_base'): return self._m_has_field_hp_base self._m_has_field_hp_base = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_hp_base', None) @property def has_field_gacha_image_name_hash(self): if hasattr(self, '_m_has_field_gacha_image_name_hash'): return self._m_has_field_gacha_image_name_hash self._m_has_field_gacha_image_name_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_gacha_image_name_hash', None) @property def has_field_sus(self): if hasattr(self, '_m_has_field_sus'): return self._m_has_field_sus self._m_has_field_sus = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_sus', None) @property def has_field_weapon_type(self): if hasattr(self, '_m_has_field_weapon_type'): return self._m_has_field_weapon_type self._m_has_field_weapon_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_weapon_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_use_type(self): if hasattr(self, '_m_has_field_use_type'): return self._m_has_field_use_type self._m_has_field_use_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_use_type', None) @property def has_field_ice_sub_hurt(self): if hasattr(self, '_m_has_field_ice_sub_hurt'): return self._m_has_field_ice_sub_hurt self._m_has_field_ice_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 16) != 0)) return getattr(self, '_m_has_field_ice_sub_hurt', None) @property def has_field_cand_skill_depot_ids(self): if hasattr(self, '_m_has_field_cand_skill_depot_ids'): return self._m_has_field_cand_skill_depot_ids self._m_has_field_cand_skill_depot_ids = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_cand_skill_depot_ids', None) @property def has_field_info_desc(self): if hasattr(self, '_m_has_field_info_desc'): return self._m_has_field_info_desc self._m_has_field_info_desc = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_info_desc', None) @property def has_field_ice_add_hurt(self): if hasattr(self, '_m_has_field_ice_add_hurt'): return self._m_has_field_ice_add_hurt self._m_has_field_ice_add_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 8) != 0)) return getattr(self, '_m_has_field_ice_add_hurt', None) @property def has_field_image_name(self): if hasattr(self, '_m_has_field_image_name'): return self._m_has_field_image_name self._m_has_field_image_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_image_name', None) @property def has_field_wind_sub_hurt(self): if hasattr(self, '_m_has_field_wind_sub_hurt'): return self._m_has_field_wind_sub_hurt self._m_has_field_wind_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 8) != 0)) return getattr(self, '_m_has_field_wind_sub_hurt', None) @property def has_field_elec_sub_hurt(self): if hasattr(self, '_m_has_field_elec_sub_hurt'): return self._m_has_field_elec_sub_hurt self._m_has_field_elec_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 4) != 0)) return getattr(self, '_m_has_field_elec_sub_hurt', None) @property def has_field_combat_config_hash(self): if hasattr(self, '_m_has_field_combat_config_hash'): return self._m_has_field_combat_config_hash self._m_has_field_combat_config_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_combat_config_hash', None) @property def has_field_fire_add_hurt(self): if hasattr(self, '_m_has_field_fire_add_hurt'): return self._m_has_field_fire_add_hurt self._m_has_field_fire_add_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 64) != 0)) return getattr(self, '_m_has_field_fire_add_hurt', None) @property def has_field_grass_sub_hurt(self): if hasattr(self, '_m_has_field_grass_sub_hurt'): return self._m_has_field_grass_sub_hurt self._m_has_field_grass_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 1) != 0)) return getattr(self, '_m_has_field_grass_sub_hurt', None) @property def has_field_avatar_promote_reward_level_list(self): if hasattr(self, '_m_has_field_avatar_promote_reward_level_list'): return self._m_has_field_avatar_promote_reward_level_list self._m_has_field_avatar_promote_reward_level_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_avatar_promote_reward_level_list', None) @property def has_field_manekin_motion_config(self): if hasattr(self, '_m_has_field_manekin_motion_config'): return self._m_has_field_manekin_motion_config self._m_has_field_manekin_motion_config = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_manekin_motion_config', None) @property def has_field_script_data_path_hash(self): if hasattr(self, '_m_has_field_script_data_path_hash'): return self._m_has_field_script_data_path_hash self._m_has_field_script_data_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_script_data_path_hash', None) @property def has_field_elec_add_hurt(self): if hasattr(self, '_m_has_field_elec_add_hurt'): return self._m_has_field_elec_add_hurt self._m_has_field_elec_add_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 2) != 0)) return getattr(self, '_m_has_field_elec_add_hurt', None) @property def has_field_feature_tag_group_id(self): if hasattr(self, '_m_has_field_feature_tag_group_id'): return self._m_has_field_feature_tag_group_id self._m_has_field_feature_tag_group_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_feature_tag_group_id', None) @property def has_field_physical_add_hurt(self): if hasattr(self, '_m_has_field_physical_add_hurt'): return self._m_has_field_physical_add_hurt self._m_has_field_physical_add_hurt = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 1) != 0)) return getattr(self, '_m_has_field_physical_add_hurt', None) @property def has_field_avatar_identity_type(self): if hasattr(self, '_m_has_field_avatar_identity_type'): return self._m_has_field_avatar_identity_type self._m_has_field_avatar_identity_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_avatar_identity_type', None) @property def has_field_body_type(self): if hasattr(self, '_m_has_field_body_type'): return self._m_has_field_body_type self._m_has_field_body_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_body_type', None) @property def has_field_element_mastery(self): if hasattr(self, '_m_has_field_element_mastery'): return self._m_has_field_element_mastery self._m_has_field_element_mastery = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 64) != 0)) return getattr(self, '_m_has_field_element_mastery', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 32) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_quality_type(self): if hasattr(self, '_m_has_field_quality_type'): return self._m_has_field_quality_type self._m_has_field_quality_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quality_type', None) @property def has_field_wind_add_hurt(self): if hasattr(self, '_m_has_field_wind_add_hurt'): return self._m_has_field_wind_add_hurt self._m_has_field_wind_add_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 4) != 0)) return getattr(self, '_m_has_field_wind_add_hurt', None) @property def has_field_avatar_promote_id(self): if hasattr(self, '_m_has_field_avatar_promote_id'): return self._m_has_field_avatar_promote_id self._m_has_field_avatar_promote_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_avatar_promote_id', None) @property def has_field_anti_critical(self): if hasattr(self, '_m_has_field_anti_critical'): return self._m_has_field_anti_critical self._m_has_field_anti_critical = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 32) != 0)) return getattr(self, '_m_has_field_anti_critical', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= (8 + 1)) and ((self.bit_field.bitfield[8] & 1) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_water_sub_hurt(self): if hasattr(self, '_m_has_field_water_sub_hurt'): return self._m_has_field_water_sub_hurt self._m_has_field_water_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 2) != 0)) return getattr(self, '_m_has_field_water_sub_hurt', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 128) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_defense_base(self): if hasattr(self, '_m_has_field_defense_base'): return self._m_has_field_defense_base self._m_has_field_defense_base = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 8) != 0)) return getattr(self, '_m_has_field_defense_base', None) @property def has_field_avatar_promote_reward_id_list(self): if hasattr(self, '_m_has_field_avatar_promote_reward_id_list'): return self._m_has_field_avatar_promote_reward_id_list self._m_has_field_avatar_promote_reward_id_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_avatar_promote_reward_id_list', None) @property def has_field_initial_weapon(self): if hasattr(self, '_m_has_field_initial_weapon'): return self._m_has_field_initial_weapon self._m_has_field_initial_weapon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_initial_weapon', None) @property def has_field_critical_hurt(self): if hasattr(self, '_m_has_field_critical_hurt'): return self._m_has_field_critical_hurt self._m_has_field_critical_hurt = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 64) != 0)) return getattr(self, '_m_has_field_critical_hurt', None) @property def has_field_side_icon_name(self): if hasattr(self, '_m_has_field_side_icon_name'): return self._m_has_field_side_icon_name self._m_has_field_side_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_side_icon_name', None) @property def has_field_charge_efficiency(self): if hasattr(self, '_m_has_field_charge_efficiency'): return self._m_has_field_charge_efficiency self._m_has_field_charge_efficiency = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_charge_efficiency', None) @property def has_field_water_add_hurt(self): if hasattr(self, '_m_has_field_water_add_hurt'): return self._m_has_field_water_add_hurt self._m_has_field_water_add_hurt = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 1) != 0)) return getattr(self, '_m_has_field_water_add_hurt', None) @property def has_field_rock_sub_hurt(self): if hasattr(self, '_m_has_field_rock_sub_hurt'): return self._m_has_field_rock_sub_hurt self._m_has_field_rock_sub_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 32) != 0)) return getattr(self, '_m_has_field_rock_sub_hurt', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 4) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 64) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_grass_add_hurt(self): if hasattr(self, '_m_has_field_grass_add_hurt'): return self._m_has_field_grass_add_hurt self._m_has_field_grass_add_hurt = ((self.bit_field.length.value >= (5 + 1)) and ((self.bit_field.bitfield[5] & 128) != 0)) return getattr(self, '_m_has_field_grass_add_hurt', None) @property def has_field_cutscene_show(self): if hasattr(self, '_m_has_field_cutscene_show'): return self._m_has_field_cutscene_show self._m_has_field_cutscene_show = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_cutscene_show', None) @property def has_field_prop_grow_curves(self): if hasattr(self, '_m_has_field_prop_grow_curves'): return self._m_has_field_prop_grow_curves self._m_has_field_prop_grow_curves = ((self.bit_field.length.value >= (6 + 1)) and ((self.bit_field.bitfield[6] & 32) != 0)) return getattr(self, '_m_has_field_prop_grow_curves', None) @property def has_field_prefab_path_ragdoll_hash(self): if hasattr(self, '_m_has_field_prefab_path_ragdoll_hash'): return self._m_has_field_prefab_path_ragdoll_hash self._m_has_field_prefab_path_ragdoll_hash = ((self.bit_field.length.value >= (7 + 1)) and ((self.bit_field.bitfield[7] & 2) != 0)) return getattr(self, '_m_has_field_prefab_path_ragdoll_hash', None) @property def has_field_gacha_card_name_hash(self): if hasattr(self, '_m_has_field_gacha_card_name_hash'): return self._m_has_field_gacha_card_name_hash self._m_has_field_gacha_card_name_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_gacha_card_name_hash', None) @property def has_field_coop_pic_name_hash(self): if hasattr(self, '_m_has_field_coop_pic_name_hash'): return self._m_has_field_coop_pic_name_hash self._m_has_field_coop_pic_name_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_coop_pic_name_hash', None) @property def has_field_animator_config_path_hash(self): if hasattr(self, '_m_has_field_animator_config_path_hash'): return self._m_has_field_animator_config_path_hash self._m_has_field_animator_config_path_hash = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_animator_config_path_hash', None) @property def has_field_is_range_attack(self): if hasattr(self, '_m_has_field_is_range_attack'): return self._m_has_field_is_range_attack self._m_has_field_is_range_attack = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_range_attack', None) class ArrayOfCoopCondLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CoopCond(self._io, self, self._root)) class EndureTemplateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumEndureType(self._io, self, self._root) if self.has_field_gauge_length: self.gauge_length = self._io.read_f4le() if self.has_field_wane_speed: self.wane_speed = self._io.read_f4le() if self.has_field_recover_time: self.recover_time = self._io.read_f4le() if self.has_field_endurance: self.endurance = self._io.read_f4le() @property def has_field_gauge_length(self): if hasattr(self, '_m_has_field_gauge_length'): return self._m_has_field_gauge_length self._m_has_field_gauge_length = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gauge_length', None) @property def has_field_wane_speed(self): if hasattr(self, '_m_has_field_wane_speed'): return self._m_has_field_wane_speed self._m_has_field_wane_speed = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_wane_speed', None) @property def has_field_recover_time(self): if hasattr(self, '_m_has_field_recover_time'): return self._m_has_field_recover_time self._m_has_field_recover_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_recover_time', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_endurance(self): if hasattr(self, '_m_has_field_endurance'): return self._m_has_field_endurance self._m_has_field_endurance = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_endurance', None) class ContextActionSelectTransPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scene_id', None) class MainQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_res_id: self.res_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_series: self.series = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestType(self._io, self, self._root) if self.has_field_main_quest_tag: self.main_quest_tag = Output.EnumMainQuestTagType(self._io, self, self._root) if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lua_path: self.lua_path = AuxTypes.String(self._io, self, self._root) if self.has_field_recommend_level: self.recommend_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_repeatable: self.repeatable = self._io.read_u1() if self.has_field_suggest_track_main_quest_list: self.suggest_track_main_quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_suggest_track_out_of_order: self.suggest_track_out_of_order = self._io.read_u1() if self.has_field_reward_id_list: self.reward_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumQuestShowType(self._io, self, self._root) if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_id: self.task_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_red_point: self.show_red_point = self._io.read_u1() if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_release: self.is_release = self._io.read_u1() if self.has_field_special_show_reward_id: self.special_show_reward_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_cond_id_list: self.special_show_cond_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_special_show_quest_id: self.special_show_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_show_red_point(self): if hasattr(self, '_m_has_field_show_red_point'): return self._m_has_field_show_red_point self._m_has_field_show_red_point = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_show_red_point', None) @property def has_field_repeatable(self): if hasattr(self, '_m_has_field_repeatable'): return self._m_has_field_repeatable self._m_has_field_repeatable = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_repeatable', None) @property def has_field_recommend_level(self): if hasattr(self, '_m_has_field_recommend_level'): return self._m_has_field_recommend_level self._m_has_field_recommend_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_recommend_level', None) @property def has_field_series(self): if hasattr(self, '_m_has_field_series'): return self._m_has_field_series self._m_has_field_series = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_series', None) @property def has_field_is_release(self): if hasattr(self, '_m_has_field_is_release'): return self._m_has_field_is_release self._m_has_field_is_release = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_is_release', None) @property def has_field_reward_id_list(self): if hasattr(self, '_m_has_field_reward_id_list'): return self._m_has_field_reward_id_list self._m_has_field_reward_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_reward_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_task_id(self): if hasattr(self, '_m_has_field_task_id'): return self._m_has_field_task_id self._m_has_field_task_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_task_id', None) @property def has_field_lua_path(self): if hasattr(self, '_m_has_field_lua_path'): return self._m_has_field_lua_path self._m_has_field_lua_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_lua_path', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_suggest_track_out_of_order(self): if hasattr(self, '_m_has_field_suggest_track_out_of_order'): return self._m_has_field_suggest_track_out_of_order self._m_has_field_suggest_track_out_of_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_suggest_track_out_of_order', None) @property def has_field_special_show_reward_id(self): if hasattr(self, '_m_has_field_special_show_reward_id'): return self._m_has_field_special_show_reward_id self._m_has_field_special_show_reward_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_special_show_reward_id', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_active_mode', None) @property def has_field_special_show_cond_id_list(self): if hasattr(self, '_m_has_field_special_show_cond_id_list'): return self._m_has_field_special_show_cond_id_list self._m_has_field_special_show_cond_id_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_special_show_cond_id_list', None) @property def has_field_special_show_quest_id(self): if hasattr(self, '_m_has_field_special_show_quest_id'): return self._m_has_field_special_show_quest_id self._m_has_field_special_show_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_special_show_quest_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_show_type', None) @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_res_id(self): if hasattr(self, '_m_has_field_res_id'): return self._m_has_field_res_id self._m_has_field_res_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_res_id', None) @property def has_field_suggest_track_main_quest_list(self): if hasattr(self, '_m_has_field_suggest_track_main_quest_list'): return self._m_has_field_suggest_track_main_quest_list self._m_has_field_suggest_track_main_quest_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_suggest_track_main_quest_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_main_quest_tag(self): if hasattr(self, '_m_has_field_main_quest_tag'): return self._m_has_field_main_quest_tag self._m_has_field_main_quest_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_main_quest_tag', None) class ArrayOfEnumTextLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumTextLanguageType(self._io, self, self._root)) class EnumSealProgressType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SealProgressType, self.data.value) return getattr(self, '_m_value', None) class ReliquaryCodexExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_suit_id: self.suit_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cup_id: self.cup_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_leather_id: self.leather_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cap_id: self.cap_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_flower_id: self.flower_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sand_id: self.sand_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_order: self.sort_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_disuse: self.is_disuse = self._io.read_u1() if self.has_field_show_only_unlocked: self.show_only_unlocked = self._io.read_u1() @property def has_field_sand_id(self): if hasattr(self, '_m_has_field_sand_id'): return self._m_has_field_sand_id self._m_has_field_sand_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_sand_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_cap_id(self): if hasattr(self, '_m_has_field_cap_id'): return self._m_has_field_cap_id self._m_has_field_cap_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cap_id', None) @property def has_field_show_only_unlocked(self): if hasattr(self, '_m_has_field_show_only_unlocked'): return self._m_has_field_show_only_unlocked self._m_has_field_show_only_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_show_only_unlocked', None) @property def has_field_leather_id(self): if hasattr(self, '_m_has_field_leather_id'): return self._m_has_field_leather_id self._m_has_field_leather_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_leather_id', None) @property def has_field_suit_id(self): if hasattr(self, '_m_has_field_suit_id'): return self._m_has_field_suit_id self._m_has_field_suit_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_suit_id', None) @property def has_field_flower_id(self): if hasattr(self, '_m_has_field_flower_id'): return self._m_has_field_flower_id self._m_has_field_flower_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_flower_id', None) @property def has_field_sort_order(self): if hasattr(self, '_m_has_field_sort_order'): return self._m_has_field_sort_order self._m_has_field_sort_order = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_sort_order', None) @property def has_field_is_disuse(self): if hasattr(self, '_m_has_field_is_disuse'): return self._m_has_field_is_disuse self._m_has_field_is_disuse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_is_disuse', None) @property def has_field_cup_id(self): if hasattr(self, '_m_has_field_cup_id'): return self._m_has_field_cup_id self._m_has_field_cup_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cup_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class EnumFacingMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FacingMoveType, self.data.value) return getattr(self, '_m_value', None) class ConfigMusicUIntPresenceStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUIntMultiValueStimulusHandler(self._io, self, self._root) @property def uint_params(self): if hasattr(self, '_m_uint_params'): return self._m_uint_params self._m_uint_params = self.base.uint_params return getattr(self, '_m_uint_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class MusicGamePreviewConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_music_id_list: self.music_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_start_quest_id: self.start_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tutorial_id: self.tutorial_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_npc_mark_id: self.npc_mark_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_music_id_list(self): if hasattr(self, '_m_has_field_music_id_list'): return self._m_has_field_music_id_list self._m_has_field_music_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_music_id_list', None) @property def has_field_start_quest_id(self): if hasattr(self, '_m_has_field_start_quest_id'): return self._m_has_field_start_quest_id self._m_has_field_start_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_start_quest_id', None) @property def has_field_npc_mark_id(self): if hasattr(self, '_m_has_field_npc_mark_id'): return self._m_has_field_npc_mark_id self._m_has_field_npc_mark_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_npc_mark_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_tutorial_id(self): if hasattr(self, '_m_has_field_tutorial_id'): return self._m_has_field_tutorial_id self._m_has_field_tutorial_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tutorial_id', None) class DispConfigBaseStateLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBaseStateLayer(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigNormalStateLayer(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigStateAudioEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_current_state_name: self.current_state_name = AuxTypes.String(self._io, self, self._root) if self.has_field_audio_event: self.audio_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_other_state_names: self.other_state_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_usage: self.usage = Output.EnumStateAudioEventUsage(self._io, self, self._root) @property def has_field_current_state_name(self): if hasattr(self, '_m_has_field_current_state_name'): return self._m_has_field_current_state_name self._m_has_field_current_state_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_current_state_name', None) @property def has_field_audio_event(self): if hasattr(self, '_m_has_field_audio_event'): return self._m_has_field_audio_event self._m_has_field_audio_event = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_audio_event', None) @property def has_field_other_state_names(self): if hasattr(self, '_m_has_field_other_state_names'): return self._m_has_field_other_state_names self._m_has_field_other_state_names = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_other_state_names', None) @property def has_field_usage(self): if hasattr(self, '_m_has_field_usage'): return self._m_has_field_usage self._m_has_field_usage = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_usage', None) class ConfigJudgeAvatarAnimatorState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_i_ds: self.config_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_config_i_ds(self): if hasattr(self, '_m_has_field_config_i_ds'): return self._m_has_field_config_i_ds self._m_has_field_config_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_i_ds', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class RandTaskTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetTurn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_move_part_around_x: self.move_part_around_x = AuxTypes.String(self._io, self, self._root) if self.has_field_anchor_part_around_x: self.anchor_part_around_x = AuxTypes.String(self._io, self, self._root) if self.has_field_move_part_around_y: self.move_part_around_y = AuxTypes.String(self._io, self, self._root) if self.has_field_anchor_part_around_y: self.anchor_part_around_y = AuxTypes.String(self._io, self, self._root) if self.has_field_move_part_around_z: self.move_part_around_z = AuxTypes.String(self._io, self, self._root) if self.has_field_anchor_part_around_z: self.anchor_part_around_z = AuxTypes.String(self._io, self, self._root) if self.has_field_audio_begin_turning_event: self.audio_begin_turning_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_stop_turning_event: self.audio_stop_turning_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_begin_turning_event_around_x: self.audio_begin_turning_event_around_x = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_stop_turning_event_around_x: self.audio_stop_turning_event_around_x = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_begin_turning_event_around_y: self.audio_begin_turning_event_around_y = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_stop_turning_event_around_y: self.audio_stop_turning_event_around_y = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_begin_turning_event_around_z: self.audio_begin_turning_event_around_z = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_audio_stop_turning_event_around_z: self.audio_stop_turning_event_around_z = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_turn_state_map: self.turn_state_map = Output.DictOfAuxTypesVlqBase128LeUConfigGadgetTurnState(self._io, self, self._root) @property def has_field_anchor_part_around_z(self): if hasattr(self, '_m_has_field_anchor_part_around_z'): return self._m_has_field_anchor_part_around_z self._m_has_field_anchor_part_around_z = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_anchor_part_around_z', None) @property def has_field_audio_begin_turning_event(self): if hasattr(self, '_m_has_field_audio_begin_turning_event'): return self._m_has_field_audio_begin_turning_event self._m_has_field_audio_begin_turning_event = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_audio_begin_turning_event', None) @property def has_field_audio_stop_turning_event_around_y(self): if hasattr(self, '_m_has_field_audio_stop_turning_event_around_y'): return self._m_has_field_audio_stop_turning_event_around_y self._m_has_field_audio_stop_turning_event_around_y = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_audio_stop_turning_event_around_y', None) @property def has_field_audio_begin_turning_event_around_z(self): if hasattr(self, '_m_has_field_audio_begin_turning_event_around_z'): return self._m_has_field_audio_begin_turning_event_around_z self._m_has_field_audio_begin_turning_event_around_z = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_audio_begin_turning_event_around_z', None) @property def has_field_audio_begin_turning_event_around_x(self): if hasattr(self, '_m_has_field_audio_begin_turning_event_around_x'): return self._m_has_field_audio_begin_turning_event_around_x self._m_has_field_audio_begin_turning_event_around_x = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_audio_begin_turning_event_around_x', None) @property def has_field_audio_stop_turning_event_around_x(self): if hasattr(self, '_m_has_field_audio_stop_turning_event_around_x'): return self._m_has_field_audio_stop_turning_event_around_x self._m_has_field_audio_stop_turning_event_around_x = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_audio_stop_turning_event_around_x', None) @property def has_field_move_part_around_x(self): if hasattr(self, '_m_has_field_move_part_around_x'): return self._m_has_field_move_part_around_x self._m_has_field_move_part_around_x = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_move_part_around_x', None) @property def has_field_anchor_part_around_x(self): if hasattr(self, '_m_has_field_anchor_part_around_x'): return self._m_has_field_anchor_part_around_x self._m_has_field_anchor_part_around_x = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_anchor_part_around_x', None) @property def has_field_move_part_around_y(self): if hasattr(self, '_m_has_field_move_part_around_y'): return self._m_has_field_move_part_around_y self._m_has_field_move_part_around_y = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_move_part_around_y', None) @property def has_field_move_part_around_z(self): if hasattr(self, '_m_has_field_move_part_around_z'): return self._m_has_field_move_part_around_z self._m_has_field_move_part_around_z = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_move_part_around_z', None) @property def has_field_turn_state_map(self): if hasattr(self, '_m_has_field_turn_state_map'): return self._m_has_field_turn_state_map self._m_has_field_turn_state_map = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_turn_state_map', None) @property def has_field_anchor_part_around_y(self): if hasattr(self, '_m_has_field_anchor_part_around_y'): return self._m_has_field_anchor_part_around_y self._m_has_field_anchor_part_around_y = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_anchor_part_around_y', None) @property def has_field_audio_stop_turning_event_around_z(self): if hasattr(self, '_m_has_field_audio_stop_turning_event_around_z'): return self._m_has_field_audio_stop_turning_event_around_z self._m_has_field_audio_stop_turning_event_around_z = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_audio_stop_turning_event_around_z', None) @property def has_field_audio_begin_turning_event_around_y(self): if hasattr(self, '_m_has_field_audio_begin_turning_event_around_y'): return self._m_has_field_audio_begin_turning_event_around_y self._m_has_field_audio_begin_turning_event_around_y = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_audio_begin_turning_event_around_y', None) @property def has_field_audio_stop_turning_event(self): if hasattr(self, '_m_has_field_audio_stop_turning_event'): return self._m_has_field_audio_stop_turning_event self._m_has_field_audio_stop_turning_event = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_audio_stop_turning_event', None) class ResetAbilitySpecial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key_name: self.key_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value_name: self.value_name = AuxTypes.String(self._io, self, self._root) @property def has_field_key_name(self): if hasattr(self, '_m_has_field_key_name'): return self._m_has_field_key_name self._m_has_field_key_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key_name', None) @property def has_field_value_name(self): if hasattr(self, '_m_has_field_value_name'): return self._m_has_field_value_name self._m_has_field_value_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value_name', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RecycleModifierMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_cd: self.cd = self._io.read_f4le() if self.has_field_initial_cd: self.initial_cd = self._io.read_f4le() @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd', None) @property def has_field_initial_cd(self): if hasattr(self, '_m_has_field_initial_cd'): return self._m_has_field_initial_cd self._m_has_field_initial_cd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_initial_cd', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumDialogGroupSchemeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DialogGroupSchemeType, self.data.value) return getattr(self, '_m_value', None) class H5activityCondConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumH5activityCondType(self._io, self, self._root) if self.has_field_param_str: self.param_str = AuxTypes.String(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param_str(self): if hasattr(self, '_m_has_field_param_str'): return self._m_has_field_param_str self._m_has_field_param_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_str', None) class ActivitySteepleChaseConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_title: self.level_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_desc: self.level_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_level_title(self): if hasattr(self, '_m_has_field_level_title'): return self._m_has_field_level_title self._m_has_field_level_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_title', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_level_desc(self): if hasattr(self, '_m_has_field_level_desc'): return self._m_has_field_level_desc self._m_has_field_level_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_level_desc', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) class ActivityMistTrialLevelDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EquipTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClearTile(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_tile_name: self.tile_name = AuxTypes.String(self._io, self, self._root) @property def has_field_tile_name(self): if hasattr(self, '_m_has_field_tile_name'): return self._m_has_field_tile_name self._m_has_field_tile_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tile_name', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SelectActionPointBySelfPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class KvpOfDictEnumTargetTypeConfigAttackInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumTargetType(self._io, self, self._root) self.value = Output.ConfigAttackInfo(self._io, self, self._root) class SubChallengeBannerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigActionTokenChannel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigActionTokenChannel(self._io, self, self._root) class ConfigMoveStateAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_on_state_begin: self.on_state_begin = Output.ArrayOfConfigStateAudioEventLengthU(self._io, self, self._root) if self.has_field_on_state_end: self.on_state_end = Output.ArrayOfConfigStateAudioEventLengthU(self._io, self, self._root) @property def has_field_on_state_begin(self): if hasattr(self, '_m_has_field_on_state_begin'): return self._m_has_field_on_state_begin self._m_has_field_on_state_begin = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_state_begin', None) @property def has_field_on_state_end(self): if hasattr(self, '_m_has_field_on_state_end'): return self._m_has_field_on_state_end self._m_has_field_on_state_end = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_state_end', None) class SectorCityManeuver(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_start: self.start = self._io.read_u1() if self.has_field_attach_point_name: self.attach_point_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_attach_point_name(self): if hasattr(self, '_m_has_field_attach_point_name'): return self._m_has_field_attach_point_name self._m_has_field_attach_point_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_point_name', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_start(self): if hasattr(self, '_m_has_field_start'): return self._m_has_field_start self._m_has_field_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start', None) class EnumWatcherSystemMixinType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WatcherSystemMixinType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideFlyFinishCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_time: self.time = self._io.read_f4le() @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_time', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class Olfcladmpah(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dlfgmmimikm: self.dlfgmmimikm = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ogmmeabhbei: self.ogmmeabhbei = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_dlfgmmimikm(self): if hasattr(self, '_m_has_field_dlfgmmimikm'): return self._m_has_field_dlfgmmimikm self._m_has_field_dlfgmmimikm = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dlfgmmimikm', None) @property def has_field_ogmmeabhbei(self): if hasattr(self, '_m_has_field_ogmmeabhbei'): return self._m_has_field_ogmmeabhbei self._m_has_field_ogmmeabhbei = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ogmmeabhbei', None) class JsonClimateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class VehicleSkillExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumDungeonEntryType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonEntryType, self.data.value) return getattr(self, '_m_value', None) class QuestDialogDecoratorExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSong(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_switch_value: self.switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_sync_transitions: self.sync_transitions = Output.ConfigMusicSyncTransitions(self._io, self, self._root) if self.has_field_time_transitions: self.time_transitions = Output.ConfigMusicTimeTransitions(self._io, self, self._root) if self.has_field_stimulus_handlers: self.stimulus_handlers = Output.ArrayOfDispConfigMusicStimulusHandlerLengthU(self._io, self, self._root) if self.has_field_ignorance_mask: self.ignorance_mask = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_sync_transitions(self): if hasattr(self, '_m_has_field_sync_transitions'): return self._m_has_field_sync_transitions self._m_has_field_sync_transitions = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sync_transitions', None) @property def has_field_stimulus_handlers(self): if hasattr(self, '_m_has_field_stimulus_handlers'): return self._m_has_field_stimulus_handlers self._m_has_field_stimulus_handlers = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_stimulus_handlers', None) @property def has_field_switch_value(self): if hasattr(self, '_m_has_field_switch_value'): return self._m_has_field_switch_value self._m_has_field_switch_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_switch_value', None) @property def has_field_time_transitions(self): if hasattr(self, '_m_has_field_time_transitions'): return self._m_has_field_time_transitions self._m_has_field_time_transitions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_time_transitions', None) @property def has_field_ignorance_mask(self): if hasattr(self, '_m_has_field_ignorance_mask'): return self._m_has_field_ignorance_mask self._m_has_field_ignorance_mask = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_ignorance_mask', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) class ConfigSubEquipController(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseEquipController(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_point: self.attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mute_ability_state: self.mute_ability_state = self._io.read_u1() @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_config_id', None) @property def dissolve_sheath_fade_delay(self): if hasattr(self, '_m_dissolve_sheath_fade_delay'): return self._m_dissolve_sheath_fade_delay self._m_dissolve_sheath_fade_delay = self.base.dissolve_sheath_fade_delay return getattr(self, '_m_dissolve_sheath_fade_delay', None) @property def trigger_to_states(self): if hasattr(self, '_m_trigger_to_states'): return self._m_trigger_to_states self._m_trigger_to_states = self.base.trigger_to_states return getattr(self, '_m_trigger_to_states', None) @property def dissolve_sheath_fade_time(self): if hasattr(self, '_m_dissolve_sheath_fade_time'): return self._m_dissolve_sheath_fade_time self._m_dissolve_sheath_fade_time = self.base.dissolve_sheath_fade_time return getattr(self, '_m_dissolve_sheath_fade_time', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_mute_ability_state(self): if hasattr(self, '_m_has_field_mute_ability_state'): return self._m_has_field_mute_ability_state self._m_has_field_mute_ability_state = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_mute_ability_state', None) @property def sheath_point(self): if hasattr(self, '_m_sheath_point'): return self._m_sheath_point self._m_sheath_point = self.base.sheath_point return getattr(self, '_m_sheath_point', None) @property def dissolve_take_fade_time(self): if hasattr(self, '_m_dissolve_take_fade_time'): return self._m_dissolve_take_fade_time self._m_dissolve_take_fade_time = self.base.dissolve_take_fade_time return getattr(self, '_m_dissolve_take_fade_time', None) @property def has_field_attach_point(self): if hasattr(self, '_m_has_field_attach_point'): return self._m_has_field_attach_point self._m_has_field_attach_point = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_point', None) class OrderingTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigStateSubEquip(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_battou_all_sub_on_start: self.battou_all_sub_on_start = self._io.read_u1() if self.has_field_sheathe_all_sub_on_start: self.sheathe_all_sub_on_start = self._io.read_u1() if self.has_field_sheathe_all_sub_on_end: self.sheathe_all_sub_on_end = self._io.read_u1() if self.has_field_battou_sub_on_start: self.battou_sub_on_start = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_sheathe_sub_on_start: self.sheathe_sub_on_start = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_sheathe_sub_on_end: self.sheathe_sub_on_end = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_sub_equip_reattach: self.sub_equip_reattach = Output.ArrayOfConfigEquipReattachLengthU(self._io, self, self._root) @property def has_field_sheathe_all_sub_on_end(self): if hasattr(self, '_m_has_field_sheathe_all_sub_on_end'): return self._m_has_field_sheathe_all_sub_on_end self._m_has_field_sheathe_all_sub_on_end = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sheathe_all_sub_on_end', None) @property def has_field_battou_sub_on_start(self): if hasattr(self, '_m_has_field_battou_sub_on_start'): return self._m_has_field_battou_sub_on_start self._m_has_field_battou_sub_on_start = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_battou_sub_on_start', None) @property def has_field_sheathe_all_sub_on_start(self): if hasattr(self, '_m_has_field_sheathe_all_sub_on_start'): return self._m_has_field_sheathe_all_sub_on_start self._m_has_field_sheathe_all_sub_on_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sheathe_all_sub_on_start', None) @property def has_field_sheathe_sub_on_end(self): if hasattr(self, '_m_has_field_sheathe_sub_on_end'): return self._m_has_field_sheathe_sub_on_end self._m_has_field_sheathe_sub_on_end = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_sheathe_sub_on_end', None) @property def has_field_battou_all_sub_on_start(self): if hasattr(self, '_m_has_field_battou_all_sub_on_start'): return self._m_has_field_battou_all_sub_on_start self._m_has_field_battou_all_sub_on_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_battou_all_sub_on_start', None) @property def has_field_sub_equip_reattach(self): if hasattr(self, '_m_has_field_sub_equip_reattach'): return self._m_has_field_sub_equip_reattach self._m_has_field_sub_equip_reattach = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_sub_equip_reattach', None) @property def has_field_sheathe_sub_on_start(self): if hasattr(self, '_m_has_field_sheathe_sub_on_start'): return self._m_has_field_sheathe_sub_on_start self._m_has_field_sheathe_sub_on_start = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_sheathe_sub_on_start', None) class SignInPeriodExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopGoodsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExhibitionCardOrderTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiGroupSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiGroupSurroundData(self._io, self, self._root) class EnumSceneMpType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneMpType, self.data.value) return getattr(self, '_m_value', None) class ContextConditionActionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_condition_name: self.condition_name = AuxTypes.String(self._io, self, self._root) if self.has_field_action_name: self.action_name = AuxTypes.String(self._io, self, self._root) @property def has_field_condition_name(self): if hasattr(self, '_m_has_field_condition_name'): return self._m_has_field_condition_name self._m_has_field_condition_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_condition_name', None) @property def has_field_action_name(self): if hasattr(self, '_m_has_field_action_name'): return self._m_has_field_action_name self._m_has_field_action_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_name', None) class EnumTextShowPlace(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TextShowPlace, self.data.value) return getattr(self, '_m_value', None) class EnumPlatformRotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PlatformRotType, self.data.value) return getattr(self, '_m_value', None) class ConfigSimpleUiShowInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_is_close: self.is_close = self._io.read_u1() if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) if self.has_field_multi_param: self.multi_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_context_name', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_is_close(self): if hasattr(self, '_m_has_field_is_close'): return self._m_has_field_is_close self._m_has_field_is_close = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_close', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_multi_param(self): if hasattr(self, '_m_has_field_multi_param'): return self._m_has_field_multi_param self._m_has_field_multi_param = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_multi_param', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ExhibitionKeyTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CreateGadgetMixinTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDangerZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigPolygonZone(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_zonelist: self.zonelist = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_zonelist(self): if hasattr(self, '_m_has_field_zonelist'): return self._m_has_field_zonelist self._m_has_field_zonelist = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_zonelist', None) @property def check_cd(self): if hasattr(self, '_m_check_cd'): return self._m_check_cd self._m_check_cd = self.base.check_cd return getattr(self, '_m_check_cd', None) class ArrayOfFlightDailyPointFactorLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FlightDailyPointFactor(self._io, self, self._root)) class SectrLayerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ModifyDamageMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_anim_event_names: self.anim_event_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_attack_type: self.attack_type = Output.EnumAttackType(self._io, self, self._root) if self.has_field_ignore_event_info: self.ignore_event_info = self._io.read_u1() if self.has_field_damage_percentage: self.damage_percentage = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_damage_percentage_ratio: self.damage_percentage_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_damage_extra: self.damage_extra = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_bonus_critical: self.bonus_critical = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_bonus_critical_hurt: self.bonus_critical_hurt = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_element_type_modifier: self.element_type_modifier = Output.ElementTypeModifier(self._io, self, self._root) if self.has_field_predicates: self.predicates = Output.ArrayOfDispConfigAbilityPredicateLengthU(self._io, self, self._root) if self.has_field_true_damage: self.true_damage = self._io.read_u1() if self.has_field_defense_ignore_ratio: self.defense_ignore_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_defense_ignore_delta: self.defense_ignore_delta = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_bonus_critical_hurt(self): if hasattr(self, '_m_has_field_bonus_critical_hurt'): return self._m_has_field_bonus_critical_hurt self._m_has_field_bonus_critical_hurt = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_bonus_critical_hurt', None) @property def has_field_anim_event_names(self): if hasattr(self, '_m_has_field_anim_event_names'): return self._m_has_field_anim_event_names self._m_has_field_anim_event_names = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_anim_event_names', None) @property def has_field_defense_ignore_ratio(self): if hasattr(self, '_m_has_field_defense_ignore_ratio'): return self._m_has_field_defense_ignore_ratio self._m_has_field_defense_ignore_ratio = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_defense_ignore_ratio', None) @property def has_field_damage_extra(self): if hasattr(self, '_m_has_field_damage_extra'): return self._m_has_field_damage_extra self._m_has_field_damage_extra = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_damage_extra', None) @property def has_field_ignore_event_info(self): if hasattr(self, '_m_has_field_ignore_event_info'): return self._m_has_field_ignore_event_info self._m_has_field_ignore_event_info = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_ignore_event_info', None) @property def has_field_true_damage(self): if hasattr(self, '_m_has_field_true_damage'): return self._m_has_field_true_damage self._m_has_field_true_damage = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_true_damage', None) @property def has_field_bonus_critical(self): if hasattr(self, '_m_has_field_bonus_critical'): return self._m_has_field_bonus_critical self._m_has_field_bonus_critical = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_bonus_critical', None) @property def has_field_damage_percentage(self): if hasattr(self, '_m_has_field_damage_percentage'): return self._m_has_field_damage_percentage self._m_has_field_damage_percentage = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_damage_percentage', None) @property def has_field_attack_type(self): if hasattr(self, '_m_has_field_attack_type'): return self._m_has_field_attack_type self._m_has_field_attack_type = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_attack_type', None) @property def has_field_damage_percentage_ratio(self): if hasattr(self, '_m_has_field_damage_percentage_ratio'): return self._m_has_field_damage_percentage_ratio self._m_has_field_damage_percentage_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_damage_percentage_ratio', None) @property def has_field_predicates(self): if hasattr(self, '_m_has_field_predicates'): return self._m_has_field_predicates self._m_has_field_predicates = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_predicates', None) @property def has_field_element_type_modifier(self): if hasattr(self, '_m_has_field_element_type_modifier'): return self._m_has_field_element_type_modifier self._m_has_field_element_type_modifier = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_element_type_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_defense_ignore_delta(self): if hasattr(self, '_m_has_field_defense_ignore_delta'): return self._m_has_field_defense_ignore_delta self._m_has_field_defense_ignore_delta = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_defense_ignore_delta', None) @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_attack_tags', None) class KvpOfDictAuxTypesStringAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class DictOfAuxTypesVlqBase128LeSTextMapLevelStruct(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSTextMapLevelStruct(self._io, self, self._root)) class ConfigGadgetConsolePosition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trans_name: self.trans_name = AuxTypes.String(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) @property def has_field_trans_name(self): if hasattr(self, '_m_has_field_trans_name'): return self._m_has_field_trans_name self._m_has_field_trans_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trans_name', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rotation', None) class EnumH5activityCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.H5activityCondType, self.data.value) return getattr(self, '_m_value', None) class ItemLimitTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRecordActorType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RecordActorType, self.data.value) return getattr(self, '_m_value', None) class ConfigPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_velocity: self.velocity = self._io.read_f4le() if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_is_reach_event: self.is_reach_event = self._io.read_u1() if self.has_field_rot_axis: self.rot_axis = Output.Vector(self._io, self, self._root) if self.has_field_rot_speed: self.rot_speed = self._io.read_f4le() if self.has_field_arrive_range: self.arrive_range = self._io.read_f4le() @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_point_id', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_velocity(self): if hasattr(self, '_m_has_field_velocity'): return self._m_has_field_velocity self._m_has_field_velocity = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_velocity', None) @property def has_field_arrive_range(self): if hasattr(self, '_m_has_field_arrive_range'): return self._m_has_field_arrive_range self._m_has_field_arrive_range = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_arrive_range', None) @property def has_field_rot_speed(self): if hasattr(self, '_m_has_field_rot_speed'): return self._m_has_field_rot_speed self._m_has_field_rot_speed = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_rot_speed', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_time', None) @property def has_field_is_reach_event(self): if hasattr(self, '_m_has_field_is_reach_event'): return self._m_has_field_is_reach_event self._m_has_field_is_reach_event = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_is_reach_event', None) @property def has_field_rot_axis(self): if hasattr(self, '_m_has_field_rot_axis'): return self._m_has_field_rot_axis self._m_has_field_rot_axis = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_rot_axis', None) class ConfigCutsceneIndex(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_normal: self.normal = Output.ConfigCutsceneContext(self._io, self, self._root) if self.has_field_platform: self.platform = Output.DictOfAuxTypesVlqBase128LeSConfigCutsceneContext(self._io, self, self._root) @property def has_field_normal(self): if hasattr(self, '_m_has_field_normal'): return self._m_has_field_normal self._m_has_field_normal = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_normal', None) @property def has_field_platform(self): if hasattr(self, '_m_has_field_platform'): return self._m_has_field_platform self._m_has_field_platform = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_platform', None) class ArrayOfConfigCrowdRestrictionGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCrowdRestrictionGroup(self._io, self, self._root)) class AvatarFlycloakExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_flycloak_id: self.flycloak_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path: self.prefab_path = AuxTypes.String(self._io, self, self._root) if self.has_field_json_name: self.json_name = AuxTypes.String(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hide: self.hide = self._io.read_u1() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_flycloak_id(self): if hasattr(self, '_m_has_field_flycloak_id'): return self._m_has_field_flycloak_id self._m_has_field_flycloak_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_flycloak_id', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_hide(self): if hasattr(self, '_m_has_field_hide'): return self._m_has_field_hide self._m_has_field_hide = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_hide', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_json_name(self): if hasattr(self, '_m_has_field_json_name'): return self._m_has_field_json_name self._m_has_field_json_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_json_name', None) @property def has_field_prefab_path(self): if hasattr(self, '_m_has_field_prefab_path'): return self._m_has_field_prefab_path self._m_has_field_prefab_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_prefab_path', None) class PerfOptionTextTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTalkLoadType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkLoadType, self.data.value) return getattr(self, '_m_value', None) class FetterInfoExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_is_hiden: self.is_hiden = self._io.read_u1() if self.has_field_info_birth_month: self.info_birth_month = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_info_birth_day: self.info_birth_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_native: self.avatar_native = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_vision_befor: self.avatar_vision_befor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_constellation_befor: self.avatar_constellation_befor = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_title: self.avatar_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_detail: self.avatar_detail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_assoc_type: self.avatar_assoc_type = Output.EnumAssocType(self._io, self, self._root) if self.has_field_cv_chinese: self.cv_chinese = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cv_japanese: self.cv_japanese = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cv_english: self.cv_english = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cv_korean: self.cv_korean = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_vision_after: self.avatar_vision_after = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_constellation_after: self.avatar_constellation_after = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) @property def has_field_avatar_constellation_befor(self): if hasattr(self, '_m_has_field_avatar_constellation_befor'): return self._m_has_field_avatar_constellation_befor self._m_has_field_avatar_constellation_befor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_avatar_constellation_befor', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_cv_chinese(self): if hasattr(self, '_m_has_field_cv_chinese'): return self._m_has_field_cv_chinese self._m_has_field_cv_chinese = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cv_chinese', None) @property def has_field_avatar_native(self): if hasattr(self, '_m_has_field_avatar_native'): return self._m_has_field_avatar_native self._m_has_field_avatar_native = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_avatar_native', None) @property def has_field_avatar_vision_befor(self): if hasattr(self, '_m_has_field_avatar_vision_befor'): return self._m_has_field_avatar_vision_befor self._m_has_field_avatar_vision_befor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_avatar_vision_befor', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_avatar_constellation_after(self): if hasattr(self, '_m_has_field_avatar_constellation_after'): return self._m_has_field_avatar_constellation_after self._m_has_field_avatar_constellation_after = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_avatar_constellation_after', None) @property def has_field_info_birth_day(self): if hasattr(self, '_m_has_field_info_birth_day'): return self._m_has_field_info_birth_day self._m_has_field_info_birth_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_info_birth_day', None) @property def has_field_cv_english(self): if hasattr(self, '_m_has_field_cv_english'): return self._m_has_field_cv_english self._m_has_field_cv_english = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_cv_english', None) @property def has_field_cv_japanese(self): if hasattr(self, '_m_has_field_cv_japanese'): return self._m_has_field_cv_japanese self._m_has_field_cv_japanese = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_cv_japanese', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_finish_conds', None) @property def has_field_cv_korean(self): if hasattr(self, '_m_has_field_cv_korean'): return self._m_has_field_cv_korean self._m_has_field_cv_korean = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_cv_korean', None) @property def has_field_avatar_title(self): if hasattr(self, '_m_has_field_avatar_title'): return self._m_has_field_avatar_title self._m_has_field_avatar_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_avatar_title', None) @property def has_field_avatar_assoc_type(self): if hasattr(self, '_m_has_field_avatar_assoc_type'): return self._m_has_field_avatar_assoc_type self._m_has_field_avatar_assoc_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_avatar_assoc_type', None) @property def has_field_info_birth_month(self): if hasattr(self, '_m_has_field_info_birth_month'): return self._m_has_field_info_birth_month self._m_has_field_info_birth_month = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_info_birth_month', None) @property def has_field_is_hiden(self): if hasattr(self, '_m_has_field_is_hiden'): return self._m_has_field_is_hiden self._m_has_field_is_hiden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_is_hiden', None) @property def has_field_avatar_vision_after(self): if hasattr(self, '_m_has_field_avatar_vision_after'): return self._m_has_field_avatar_vision_after self._m_has_field_avatar_vision_after = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_avatar_vision_after', None) @property def has_field_avatar_detail(self): if hasattr(self, '_m_has_field_avatar_detail'): return self._m_has_field_avatar_detail self._m_has_field_avatar_detail = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_avatar_detail', None) class ArrayOfCameraPlayConditionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CameraPlayCondition(self._io, self, self._root)) class ScenePointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigQteStepBaseComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigQteStepBaseComponent(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigQteStepButtonComponent(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigQteStepPowerBarComponent(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class VirtualTransPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SceneTransPoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_mark_icon_type_name: self.mark_icon_type_name = AuxTypes.String(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def max_spring_volume(self): if hasattr(self, '_m_max_spring_volume'): return self._m_max_spring_volume self._m_max_spring_volume = self.base.max_spring_volume return getattr(self, '_m_max_spring_volume', None) @property def disable_interaction(self): if hasattr(self, '_m_disable_interaction'): return self._m_disable_interaction self._m_disable_interaction = self.base.disable_interaction return getattr(self, '_m_disable_interaction', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def npc_id(self): if hasattr(self, '_m_npc_id'): return self._m_npc_id self._m_npc_id = self.base.npc_id return getattr(self, '_m_npc_id', None) @property def map_visibility(self): if hasattr(self, '_m_map_visibility'): return self._m_map_visibility self._m_map_visibility = self.base.map_visibility return getattr(self, '_m_map_visibility', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def cutscene_list(self): if hasattr(self, '_m_cutscene_list'): return self._m_cutscene_list self._m_cutscene_list = self.base.cutscene_list return getattr(self, '_m_cutscene_list', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def is_forbid_avatar_auto_use_spring(self): if hasattr(self, '_m_is_forbid_avatar_auto_use_spring'): return self._m_is_forbid_avatar_auto_use_spring self._m_is_forbid_avatar_auto_use_spring = self.base.is_forbid_avatar_auto_use_spring return getattr(self, '_m_is_forbid_avatar_auto_use_spring', None) @property def show_on_locked_area(self): if hasattr(self, '_m_show_on_locked_area'): return self._m_show_on_locked_area self._m_show_on_locked_area = self.base.show_on_locked_area return getattr(self, '_m_show_on_locked_area', None) @property def is_forbid_avatar_revive(self): if hasattr(self, '_m_is_forbid_avatar_revive'): return self._m_is_forbid_avatar_revive self._m_is_forbid_avatar_revive = self.base.is_forbid_avatar_revive return getattr(self, '_m_is_forbid_avatar_revive', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_mark_icon_type_name(self): if hasattr(self, '_m_has_field_mark_icon_type_name'): return self._m_has_field_mark_icon_type_name self._m_has_field_mark_icon_type_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mark_icon_type_name', None) class EnumProductType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProductType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeUCoopSubStartPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.CoopSubStartPoint(self._io, self, self._root) class KvpOfDictAuxTypesStringConfigEliteShieldResistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigEliteShieldResistance(self._io, self, self._root) class DungeonChallengeConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target_text_template: self.target_text_template = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_target_text_template: self.sub_target_text_template = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_progress_text_template: self.progress_text_template = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_progress_text_template: self.sub_progress_text_template = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_challenge_type: self.challenge_type = Output.EnumChallengeType(self._io, self, self._root) if self.has_field_is_forward_timing: self.is_forward_timing = self._io.read_u1() if self.has_field_record_type: self.record_type = Output.EnumChallengeRecordType(self._io, self, self._root) if self.has_field_no_success_hint: self.no_success_hint = self._io.read_u1() if self.has_field_no_fail_hint: self.no_fail_hint = self._io.read_u1() if self.has_field_no_pause_hint: self.no_pause_hint = self._io.read_u1() if self.has_field_interrupt_button_type: self.interrupt_button_type = Output.EnumInterruptButtonType(self._io, self, self._root) if self.has_field_is_trans_back_when_interrupt: self.is_trans_back_when_interrupt = self._io.read_u1() if self.has_field_is_success_when_not_settled: self.is_success_when_not_settled = self._io.read_u1() if self.has_field_is_block_top_timer: self.is_block_top_timer = self._io.read_u1() if self.has_field_sub_challenge_fade_out_rule: self.sub_challenge_fade_out_rule = Output.EnumSubChallengeFadeOutType(self._io, self, self._root) if self.has_field_sub_challenge_fade_out_delay_time: self.sub_challenge_fade_out_delay_time = self._io.read_f4le() if self.has_field_sub_challenge_banner_rule: self.sub_challenge_banner_rule = Output.EnumSubChallengeBannerType(self._io, self, self._root) if self.has_field_activity_skill_id: self.activity_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_team_ability_group_list: self.team_ability_group_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_is_forward_timing(self): if hasattr(self, '_m_has_field_is_forward_timing'): return self._m_has_field_is_forward_timing self._m_has_field_is_forward_timing = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_forward_timing', None) @property def has_field_no_success_hint(self): if hasattr(self, '_m_has_field_no_success_hint'): return self._m_has_field_no_success_hint self._m_has_field_no_success_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_no_success_hint', None) @property def has_field_progress_text_template(self): if hasattr(self, '_m_has_field_progress_text_template'): return self._m_has_field_progress_text_template self._m_has_field_progress_text_template = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_progress_text_template', None) @property def has_field_sub_progress_text_template(self): if hasattr(self, '_m_has_field_sub_progress_text_template'): return self._m_has_field_sub_progress_text_template self._m_has_field_sub_progress_text_template = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sub_progress_text_template', None) @property def has_field_is_block_top_timer(self): if hasattr(self, '_m_has_field_is_block_top_timer'): return self._m_has_field_is_block_top_timer self._m_has_field_is_block_top_timer = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_block_top_timer', None) @property def has_field_sub_challenge_fade_out_rule(self): if hasattr(self, '_m_has_field_sub_challenge_fade_out_rule'): return self._m_has_field_sub_challenge_fade_out_rule self._m_has_field_sub_challenge_fade_out_rule = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_sub_challenge_fade_out_rule', None) @property def has_field_no_pause_hint(self): if hasattr(self, '_m_has_field_no_pause_hint'): return self._m_has_field_no_pause_hint self._m_has_field_no_pause_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_no_pause_hint', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_sub_target_text_template(self): if hasattr(self, '_m_has_field_sub_target_text_template'): return self._m_has_field_sub_target_text_template self._m_has_field_sub_target_text_template = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sub_target_text_template', None) @property def has_field_record_type(self): if hasattr(self, '_m_has_field_record_type'): return self._m_has_field_record_type self._m_has_field_record_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_record_type', None) @property def has_field_interrupt_button_type(self): if hasattr(self, '_m_has_field_interrupt_button_type'): return self._m_has_field_interrupt_button_type self._m_has_field_interrupt_button_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_interrupt_button_type', None) @property def has_field_is_success_when_not_settled(self): if hasattr(self, '_m_has_field_is_success_when_not_settled'): return self._m_has_field_is_success_when_not_settled self._m_has_field_is_success_when_not_settled = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_is_success_when_not_settled', None) @property def has_field_no_fail_hint(self): if hasattr(self, '_m_has_field_no_fail_hint'): return self._m_has_field_no_fail_hint self._m_has_field_no_fail_hint = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_no_fail_hint', None) @property def has_field_is_trans_back_when_interrupt(self): if hasattr(self, '_m_has_field_is_trans_back_when_interrupt'): return self._m_has_field_is_trans_back_when_interrupt self._m_has_field_is_trans_back_when_interrupt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_is_trans_back_when_interrupt', None) @property def has_field_sub_challenge_fade_out_delay_time(self): if hasattr(self, '_m_has_field_sub_challenge_fade_out_delay_time'): return self._m_has_field_sub_challenge_fade_out_delay_time self._m_has_field_sub_challenge_fade_out_delay_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_sub_challenge_fade_out_delay_time', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_skill_id(self): if hasattr(self, '_m_has_field_activity_skill_id'): return self._m_has_field_activity_skill_id self._m_has_field_activity_skill_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_activity_skill_id', None) @property def has_field_challenge_type(self): if hasattr(self, '_m_has_field_challenge_type'): return self._m_has_field_challenge_type self._m_has_field_challenge_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_challenge_type', None) @property def has_field_team_ability_group_list(self): if hasattr(self, '_m_has_field_team_ability_group_list'): return self._m_has_field_team_ability_group_list self._m_has_field_team_ability_group_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_team_ability_group_list', None) @property def has_field_sub_challenge_banner_rule(self): if hasattr(self, '_m_has_field_sub_challenge_banner_rule'): return self._m_has_field_sub_challenge_banner_rule self._m_has_field_sub_challenge_banner_rule = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_sub_challenge_banner_rule', None) @property def has_field_target_text_template(self): if hasattr(self, '_m_has_field_target_text_template'): return self._m_has_field_target_text_template self._m_has_field_target_text_template = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_target_text_template', None) class QuestSpecialShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WorldLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAudioMutualExclusionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioMutualExclusion(self._io, self, self._root)) class ConfigNpc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCharacter(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_dither: self.default_dither = self._io.read_f4le() if self.has_field_disappear_duration: self.disappear_duration = self._io.read_f4le() if self.has_field_aibeta: self.aibeta = Output.ConfigAiBeta(self._io, self, self._root) if self.has_field_move: self.move = Output.DispConfigMove(self._io, self, self._root) if self.has_field_intee: self.intee = Output.ConfigIntee(self._io, self, self._root) if self.has_field_audio: self.audio = Output.DispConfigEntityAudio(self._io, self, self._root) if self.has_field_emoji_bubble: self.emoji_bubble = Output.ConfigEmojiBubble(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def bind_emotions(self): if hasattr(self, '_m_bind_emotions'): return self._m_bind_emotions self._m_bind_emotions = self.base.bind_emotions return getattr(self, '_m_bind_emotions', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def billboard(self): if hasattr(self, '_m_billboard'): return self._m_billboard self._m_billboard = self.base.billboard return getattr(self, '_m_billboard', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_audio(self): if hasattr(self, '_m_has_field_audio'): return self._m_has_field_audio self._m_has_field_audio = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_audio', None) @property def equip_controller(self): if hasattr(self, '_m_equip_controller'): return self._m_equip_controller self._m_equip_controller = self.base.equip_controller return getattr(self, '_m_equip_controller', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) @property def has_field_default_dither(self): if hasattr(self, '_m_has_field_default_dither'): return self._m_has_field_default_dither self._m_has_field_default_dither = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_dither', None) @property def sub_equip_controllers(self): if hasattr(self, '_m_sub_equip_controllers'): return self._m_sub_equip_controllers self._m_sub_equip_controllers = self.base.sub_equip_controllers return getattr(self, '_m_sub_equip_controllers', None) @property def abilities(self): if hasattr(self, '_m_abilities'): return self._m_abilities self._m_abilities = self.base.abilities return getattr(self, '_m_abilities', None) @property def has_field_move(self): if hasattr(self, '_m_has_field_move'): return self._m_has_field_move self._m_has_field_move = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_move', None) @property def has_field_disappear_duration(self): if hasattr(self, '_m_has_field_disappear_duration'): return self._m_has_field_disappear_duration self._m_has_field_disappear_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_disappear_duration', None) @property def has_field_emoji_bubble(self): if hasattr(self, '_m_has_field_emoji_bubble'): return self._m_has_field_emoji_bubble self._m_has_field_emoji_bubble = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_emoji_bubble', None) @property def has_field_aibeta(self): if hasattr(self, '_m_has_field_aibeta'): return self._m_has_field_aibeta self._m_has_field_aibeta = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_aibeta', None) @property def face(self): if hasattr(self, '_m_face'): return self._m_face self._m_face = self.base.face return getattr(self, '_m_face', None) @property def part_control(self): if hasattr(self, '_m_part_control'): return self._m_part_control self._m_part_control = self.base.part_control return getattr(self, '_m_part_control', None) @property def combat(self): if hasattr(self, '_m_combat'): return self._m_combat self._m_combat = self.base.combat return getattr(self, '_m_combat', None) @property def has_field_intee(self): if hasattr(self, '_m_has_field_intee'): return self._m_has_field_intee self._m_has_field_intee = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_intee', None) @property def state_layers(self): if hasattr(self, '_m_state_layers'): return self._m_state_layers self._m_state_layers = self.base.state_layers return getattr(self, '_m_state_layers', None) class ConfigBlossomDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class Summon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_born_slot_index: self.born_slot_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_face_to_target: self.face_to_target = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_summon_tag: self.summon_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_alive_by_owner: self.alive_by_owner = self._io.read_u1() if self.has_field_is_elite: self.is_elite = self._io.read_u1() if self.has_field_affix_list: self.affix_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_delta: self.level_delta = AuxTypes.DynamicInt(self._io, self, self._root) if self.has_field_has_drop: self.has_drop = self._io.read_u1() if self.has_field_has_exp: self.has_exp = self._io.read_u1() if self.has_field_sight_group_with_owner: self.sight_group_with_owner = self._io.read_u1() @property def has_field_level_delta(self): if hasattr(self, '_m_has_field_level_delta'): return self._m_has_field_level_delta self._m_has_field_level_delta = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_level_delta', None) @property def has_field_sight_group_with_owner(self): if hasattr(self, '_m_has_field_sight_group_with_owner'): return self._m_has_field_sight_group_with_owner self._m_has_field_sight_group_with_owner = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_sight_group_with_owner', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_summon_tag(self): if hasattr(self, '_m_has_field_summon_tag'): return self._m_has_field_summon_tag self._m_has_field_summon_tag = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_summon_tag', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_monster_id', None) @property def has_field_is_elite(self): if hasattr(self, '_m_has_field_is_elite'): return self._m_has_field_is_elite self._m_has_field_is_elite = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_is_elite', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_born_slot_index(self): if hasattr(self, '_m_has_field_born_slot_index'): return self._m_has_field_born_slot_index self._m_has_field_born_slot_index = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_born_slot_index', None) @property def has_field_has_drop(self): if hasattr(self, '_m_has_field_has_drop'): return self._m_has_field_has_drop self._m_has_field_has_drop = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_has_drop', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_alive_by_owner(self): if hasattr(self, '_m_has_field_alive_by_owner'): return self._m_has_field_alive_by_owner self._m_has_field_alive_by_owner = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_alive_by_owner', None) @property def has_field_has_exp(self): if hasattr(self, '_m_has_field_has_exp'): return self._m_has_field_has_exp self._m_has_field_has_exp = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_has_exp', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_face_to_target(self): if hasattr(self, '_m_has_field_face_to_target'): return self._m_has_field_face_to_target self._m_has_field_face_to_target = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_face_to_target', None) @property def has_field_affix_list(self): if hasattr(self, '_m_has_field_affix_list'): return self._m_has_field_affix_list self._m_has_field_affix_list = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_affix_list', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_born', None) class ReputationEntranceCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumReputationEntranceCondType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class ConfigAiFollowServerRouteData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override_walk: self.turn_speed_override_walk = self._io.read_f4le() if self.has_field_turn_speed_override_run: self.turn_speed_override_run = self._io.read_f4le() if self.has_field_check_range: self.check_range = self._io.read_f4le() if self.has_field_special: self.special = self._io.read_u1() @property def has_field_turn_speed_override_walk(self): if hasattr(self, '_m_has_field_turn_speed_override_walk'): return self._m_has_field_turn_speed_override_walk self._m_has_field_turn_speed_override_walk = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override_walk', None) @property def has_field_check_range(self): if hasattr(self, '_m_has_field_check_range'): return self._m_has_field_check_range self._m_has_field_check_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_check_range', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_turn_speed_override_run(self): if hasattr(self, '_m_has_field_turn_speed_override_run'): return self._m_has_field_turn_speed_override_run self._m_has_field_turn_speed_override_run = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_turn_speed_override_run', None) @property def has_field_special(self): if hasattr(self, '_m_has_field_special'): return self._m_has_field_special self._m_has_field_special = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_special', None) class DailyTaskExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pool_id: self.pool_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDailyTaskType(self._io, self, self._root) if self.has_field_rarity: self.rarity = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_old_group_vec: self.old_group_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_new_group_vec: self.new_group_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_finish_type: self.finish_type = Output.EnumDailyTaskFinishType(self._io, self, self._root) if self.has_field_finish_param1: self.finish_param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_param2: self.finish_param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_progress: self.finish_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_reward_id: self.task_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_position: self.center_position = AuxTypes.String(self._io, self, self._root) if self.has_field_enter_distance: self.enter_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exit_distance: self.exit_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_description: self.description = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target: self.target = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radar_radius: self.radar_radius = self._io.read_f4le() @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_finish_param2(self): if hasattr(self, '_m_has_field_finish_param2'): return self._m_has_field_finish_param2 self._m_has_field_finish_param2 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_finish_param2', None) @property def has_field_exit_distance(self): if hasattr(self, '_m_has_field_exit_distance'): return self._m_has_field_exit_distance self._m_has_field_exit_distance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_exit_distance', None) @property def has_field_center_position(self): if hasattr(self, '_m_has_field_center_position'): return self._m_has_field_center_position self._m_has_field_center_position = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_center_position', None) @property def has_field_finish_progress(self): if hasattr(self, '_m_has_field_finish_progress'): return self._m_has_field_finish_progress self._m_has_field_finish_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_finish_progress', None) @property def has_field_pool_id(self): if hasattr(self, '_m_has_field_pool_id'): return self._m_has_field_pool_id self._m_has_field_pool_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pool_id', None) @property def has_field_finish_param1(self): if hasattr(self, '_m_has_field_finish_param1'): return self._m_has_field_finish_param1 self._m_has_field_finish_param1 = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_finish_param1', None) @property def has_field_new_group_vec(self): if hasattr(self, '_m_has_field_new_group_vec'): return self._m_has_field_new_group_vec self._m_has_field_new_group_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_new_group_vec', None) @property def has_field_radar_radius(self): if hasattr(self, '_m_has_field_radar_radius'): return self._m_has_field_radar_radius self._m_has_field_radar_radius = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_radar_radius', None) @property def has_field_old_group_vec(self): if hasattr(self, '_m_has_field_old_group_vec'): return self._m_has_field_old_group_vec self._m_has_field_old_group_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_old_group_vec', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_enter_distance(self): if hasattr(self, '_m_has_field_enter_distance'): return self._m_has_field_enter_distance self._m_has_field_enter_distance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_enter_distance', None) @property def has_field_task_reward_id(self): if hasattr(self, '_m_has_field_task_reward_id'): return self._m_has_field_task_reward_id self._m_has_field_task_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_task_reward_id', None) @property def has_field_finish_type(self): if hasattr(self, '_m_has_field_finish_type'): return self._m_has_field_finish_type self._m_has_field_finish_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_finish_type', None) @property def has_field_description(self): if hasattr(self, '_m_has_field_description'): return self._m_has_field_description self._m_has_field_description = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_description', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_rarity(self): if hasattr(self, '_m_has_field_rarity'): return self._m_has_field_rarity self._m_has_field_rarity = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_rarity', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_target', None) class ConfigMusicDoubleGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CustomGadgetTabExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tab_id: self.tab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tab_name: self.tab_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_slot_identifier_path_list: self.slot_identifier_path_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_dependent_tab_id: self.dependent_tab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_slot_select: self.effect_slot_select = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_parts_setup: self.effect_parts_setup = AuxTypes.String(self._io, self, self._root) if self.has_field_no_parts_tips: self.no_parts_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_get_parts_tips: self.get_parts_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_tab_name(self): if hasattr(self, '_m_has_field_tab_name'): return self._m_has_field_tab_name self._m_has_field_tab_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_tab_name', None) @property def has_field_get_parts_tips(self): if hasattr(self, '_m_has_field_get_parts_tips'): return self._m_has_field_get_parts_tips self._m_has_field_get_parts_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_get_parts_tips', None) @property def has_field_slot_identifier_path_list(self): if hasattr(self, '_m_has_field_slot_identifier_path_list'): return self._m_has_field_slot_identifier_path_list self._m_has_field_slot_identifier_path_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_slot_identifier_path_list', None) @property def has_field_tab_id(self): if hasattr(self, '_m_has_field_tab_id'): return self._m_has_field_tab_id self._m_has_field_tab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tab_id', None) @property def has_field_effect_slot_select(self): if hasattr(self, '_m_has_field_effect_slot_select'): return self._m_has_field_effect_slot_select self._m_has_field_effect_slot_select = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_effect_slot_select', None) @property def has_field_effect_parts_setup(self): if hasattr(self, '_m_has_field_effect_parts_setup'): return self._m_has_field_effect_parts_setup self._m_has_field_effect_parts_setup = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_parts_setup', None) @property def has_field_dependent_tab_id(self): if hasattr(self, '_m_has_field_dependent_tab_id'): return self._m_has_field_dependent_tab_id self._m_has_field_dependent_tab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_dependent_tab_id', None) @property def has_field_no_parts_tips(self): if hasattr(self, '_m_has_field_no_parts_tips'): return self._m_has_field_no_parts_tips self._m_has_field_no_parts_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_no_parts_tips', None) class ApplyInertiaVelocityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_damping: self.damping = self._io.read_f4le() if self.has_field_use_xz: self.use_xz = self._io.read_u1() if self.has_field_use_y: self.use_y = self._io.read_u1() @property def has_field_damping(self): if hasattr(self, '_m_has_field_damping'): return self._m_has_field_damping self._m_has_field_damping = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_damping', None) @property def has_field_use_xz(self): if hasattr(self, '_m_has_field_use_xz'): return self._m_has_field_use_xz self._m_has_field_use_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_use_xz', None) @property def has_field_use_y(self): if hasattr(self, '_m_has_field_use_y'): return self._m_has_field_use_y self._m_has_field_use_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_y', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class RecordOverrideTexture(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.String(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) class ConfigSkin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductPsnCompensationDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPlatformUiAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPlatformUiAction(self._io, self, self._root) class TypeCountComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFlycloakFashion(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effects: self.effects = Output.ConfigFlycloakFashionEffect(self._io, self, self._root) if self.has_field_scale: self.scale = Output.ConfigFlycloakFashionScale(self._io, self, self._root) @property def has_field_effects(self): if hasattr(self, '_m_has_field_effects'): return self._m_has_field_effects self._m_has_field_effects = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effects', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_scale', None) class ConfigGuideForceAvatarMoveAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_angle: self.angle = self._io.read_f4le() if self.has_field_mold: self.mold = self._io.read_f4le() @property def has_field_angle(self): if hasattr(self, '_m_has_field_angle'): return self._m_has_field_angle self._m_has_field_angle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_angle', None) @property def has_field_mold(self): if hasattr(self, '_m_has_field_mold'): return self._m_has_field_mold self._m_has_field_mold = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mold', None) class ByHitBoxName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_hit_box_names: self.hit_box_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_hit_box_names(self): if hasattr(self, '_m_has_field_hit_box_names'): return self._m_has_field_hit_box_names self._m_has_field_hit_box_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_box_names', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class FlightActivityMedalExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BlossomGroupsExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MusicGamePositionConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumUnstickAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UnstickAction, self.data.value) return getattr(self, '_m_value', None) class ArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(AuxTypes.VlqBase128LeU(self._io, self, self._root)) class HideAndSeekSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_category: self.skill_category = Output.EnumHideAndSeekSkillCategory(self._io, self, self._root) if self.has_field_skill_sub_category: self.skill_sub_category = Output.EnumHideAndSeekSkillSubCategory(self._io, self, self._root) if self.has_field_is_default: self.is_default = self._io.read_u1() if self.has_field_category_desc: self.category_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_icon_path_hash: self.skill_icon_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_icon_path_hash: self.skill_icon_path_hash_pre = self._io.read_s1() @property def has_field_is_default(self): if hasattr(self, '_m_has_field_is_default'): return self._m_has_field_is_default self._m_has_field_is_default = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_default', None) @property def has_field_skill_category(self): if hasattr(self, '_m_has_field_skill_category'): return self._m_has_field_skill_category self._m_has_field_skill_category = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_skill_category', None) @property def has_field_skill_sub_category(self): if hasattr(self, '_m_has_field_skill_sub_category'): return self._m_has_field_skill_sub_category self._m_has_field_skill_sub_category = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_skill_sub_category', None) @property def has_field_skill_icon_path_hash(self): if hasattr(self, '_m_has_field_skill_icon_path_hash'): return self._m_has_field_skill_icon_path_hash self._m_has_field_skill_icon_path_hash = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_skill_icon_path_hash', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_skill_id', None) @property def has_field_category_desc(self): if hasattr(self, '_m_has_field_category_desc'): return self._m_has_field_category_desc self._m_has_field_category_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_category_desc', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_challenge_id', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_order', None) class BartenderMixingStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MarkLayerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigWidgetToyLunchBoxHealMaterial(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_notice_add_hp_materials: self.notice_add_hp_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_other_add_hp_materials: self.other_add_hp_materials = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_notice_add_hp_materials(self): if hasattr(self, '_m_has_field_notice_add_hp_materials'): return self._m_has_field_notice_add_hp_materials self._m_has_field_notice_add_hp_materials = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_notice_add_hp_materials', None) @property def has_field_other_add_hp_materials(self): if hasattr(self, '_m_has_field_other_add_hp_materials'): return self._m_has_field_other_add_hp_materials self._m_has_field_other_add_hp_materials = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_other_add_hp_materials', None) class MaterialExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_interaction_title: self.interaction_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_type: self.material_type = Output.EnumMaterialType(self._io, self, self._root) if self.has_field_cd_time: self.cd_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_group: self.cd_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stack_limit: self.stack_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_use_count: self.max_use_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_use_on_gain: self.use_on_gain = self._io.read_u1() if self.has_field_no_first_get_hint: self.no_first_get_hint = self._io.read_u1() if self.has_field_play_gain_effect: self.play_gain_effect = self._io.read_u1() if self.has_field_use_target: self.use_target = Output.EnumItemUseTarget(self._io, self, self._root) if self.has_field_item_use: self.item_use = Output.ArrayOfItemUseConfigLengthS(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_food_quality: self.food_quality = Output.EnumFoodQualityType(self._io, self, self._root) if self.has_field_effect_desc: self.effect_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_desc: self.special_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type_desc: self.type_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_icon: self.effect_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_effect_gadget_id: self.effect_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_name: self.effect_name = AuxTypes.String(self._io, self, self._root) if self.has_field_pic_path: self.pic_path = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_split_drop: self.is_split_drop = self._io.read_u1() if self.has_field_close_bag_after_used: self.close_bag_after_used = self._io.read_u1() if self.has_field_satiation_params: self.satiation_params = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_destroy_rule: self.destroy_rule = Output.EnumMaterialDestroyType(self._io, self, self._root) if self.has_field_destroy_return_material: self.destroy_return_material = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_destroy_return_material_count: self.destroy_return_material_count = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_set_id: self.set_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_hidden: self.is_hidden = self._io.read_u1() if self.has_field_is_force_get_hint: self.is_force_get_hint = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_material_type(self): if hasattr(self, '_m_has_field_material_type'): return self._m_has_field_material_type self._m_has_field_material_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_material_type', None) @property def has_field_use_on_gain(self): if hasattr(self, '_m_has_field_use_on_gain'): return self._m_has_field_use_on_gain self._m_has_field_use_on_gain = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_use_on_gain', None) @property def has_field_is_split_drop(self): if hasattr(self, '_m_has_field_is_split_drop'): return self._m_has_field_is_split_drop self._m_has_field_is_split_drop = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_is_split_drop', None) @property def has_field_destroy_rule(self): if hasattr(self, '_m_has_field_destroy_rule'): return self._m_has_field_destroy_rule self._m_has_field_destroy_rule = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_destroy_rule', None) @property def has_field_pic_path(self): if hasattr(self, '_m_has_field_pic_path'): return self._m_has_field_pic_path self._m_has_field_pic_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_pic_path', None) @property def has_field_is_hidden(self): if hasattr(self, '_m_has_field_is_hidden'): return self._m_has_field_is_hidden self._m_has_field_is_hidden = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_is_hidden', None) @property def has_field_type_desc(self): if hasattr(self, '_m_has_field_type_desc'): return self._m_has_field_type_desc self._m_has_field_type_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_type_desc', None) @property def has_field_is_force_get_hint(self): if hasattr(self, '_m_has_field_is_force_get_hint'): return self._m_has_field_is_force_get_hint self._m_has_field_is_force_get_hint = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_is_force_get_hint', None) @property def has_field_destroy_return_material(self): if hasattr(self, '_m_has_field_destroy_return_material'): return self._m_has_field_destroy_return_material self._m_has_field_destroy_return_material = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_destroy_return_material', None) @property def has_field_item_use(self): if hasattr(self, '_m_has_field_item_use'): return self._m_has_field_item_use self._m_has_field_item_use = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_item_use', None) @property def has_field_effect_gadget_id(self): if hasattr(self, '_m_has_field_effect_gadget_id'): return self._m_has_field_effect_gadget_id self._m_has_field_effect_gadget_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_effect_gadget_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_effect_desc(self): if hasattr(self, '_m_has_field_effect_desc'): return self._m_has_field_effect_desc self._m_has_field_effect_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_effect_desc', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 8) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 32) != 0)) return getattr(self, '_m_has_field_dropable', None) @property def has_field_use_target(self): if hasattr(self, '_m_has_field_use_target'): return self._m_has_field_use_target self._m_has_field_use_target = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_use_target', None) @property def has_field_special_desc(self): if hasattr(self, '_m_has_field_special_desc'): return self._m_has_field_special_desc self._m_has_field_special_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_special_desc', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_max_use_count(self): if hasattr(self, '_m_has_field_max_use_count'): return self._m_has_field_max_use_count self._m_has_field_max_use_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_max_use_count', None) @property def has_field_no_first_get_hint(self): if hasattr(self, '_m_has_field_no_first_get_hint'): return self._m_has_field_no_first_get_hint self._m_has_field_no_first_get_hint = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_no_first_get_hint', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 16) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 64) != 0)) return getattr(self, '_m_has_field_use_level', None) @property def has_field_interaction_title(self): if hasattr(self, '_m_has_field_interaction_title'): return self._m_has_field_interaction_title self._m_has_field_interaction_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_interaction_title', None) @property def has_field_effect_name(self): if hasattr(self, '_m_has_field_effect_name'): return self._m_has_field_effect_name self._m_has_field_effect_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_effect_name', None) @property def has_field_cd_group(self): if hasattr(self, '_m_has_field_cd_group'): return self._m_has_field_cd_group self._m_has_field_cd_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_cd_group', None) @property def has_field_stack_limit(self): if hasattr(self, '_m_has_field_stack_limit'): return self._m_has_field_stack_limit self._m_has_field_stack_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_stack_limit', None) @property def has_field_set_id(self): if hasattr(self, '_m_has_field_set_id'): return self._m_has_field_set_id self._m_has_field_set_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_set_id', None) @property def has_field_effect_icon(self): if hasattr(self, '_m_has_field_effect_icon'): return self._m_has_field_effect_icon self._m_has_field_effect_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_effect_icon', None) @property def has_field_cd_time(self): if hasattr(self, '_m_has_field_cd_time'): return self._m_has_field_cd_time self._m_has_field_cd_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cd_time', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 128) != 0)) return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_satiation_params(self): if hasattr(self, '_m_has_field_satiation_params'): return self._m_has_field_satiation_params self._m_has_field_satiation_params = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_satiation_params', None) @property def has_field_close_bag_after_used(self): if hasattr(self, '_m_has_field_close_bag_after_used'): return self._m_has_field_close_bag_after_used self._m_has_field_close_bag_after_used = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_close_bag_after_used', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_item_type', None) @property def has_field_play_gain_effect(self): if hasattr(self, '_m_has_field_play_gain_effect'): return self._m_has_field_play_gain_effect self._m_has_field_play_gain_effect = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_play_gain_effect', None) @property def has_field_food_quality(self): if hasattr(self, '_m_has_field_food_quality'): return self._m_has_field_food_quality self._m_has_field_food_quality = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_food_quality', None) @property def has_field_destroy_return_material_count(self): if hasattr(self, '_m_has_field_destroy_return_material_count'): return self._m_has_field_destroy_return_material_count self._m_has_field_destroy_return_material_count = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_destroy_return_material_count', None) class EnumGivingMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GivingMethod, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringDispConfigBaseWidget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigBaseWidget(self._io, self, self._root) class ConfigAiSpacialChaseData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_chase_start_distance: self.chase_start_distance = self._io.read_f4le() if self.has_field_chase_stop_distance: self.chase_stop_distance = self._io.read_f4le() if self.has_field_y_offset_min: self.y_offset_min = self._io.read_f4le() if self.has_field_y_offset_max: self.y_offset_max = self._io.read_f4le() if self.has_field_segment_distance: self.segment_distance = self._io.read_f4le() if self.has_field_can_start_range_by_raycast: self.can_start_range_by_raycast = Output.ArrayOfConfigAiRaycastConditionLengthU(self._io, self, self._root) @property def has_field_segment_distance(self): if hasattr(self, '_m_has_field_segment_distance'): return self._m_has_field_segment_distance self._m_has_field_segment_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_segment_distance', None) @property def has_field_y_offset_max(self): if hasattr(self, '_m_has_field_y_offset_max'): return self._m_has_field_y_offset_max self._m_has_field_y_offset_max = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_y_offset_max', None) @property def has_field_chase_start_distance(self): if hasattr(self, '_m_has_field_chase_start_distance'): return self._m_has_field_chase_start_distance self._m_has_field_chase_start_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_chase_start_distance', None) @property def has_field_can_start_range_by_raycast(self): if hasattr(self, '_m_has_field_can_start_range_by_raycast'): return self._m_has_field_can_start_range_by_raycast self._m_has_field_can_start_range_by_raycast = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_can_start_range_by_raycast', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_y_offset_min(self): if hasattr(self, '_m_has_field_y_offset_min'): return self._m_has_field_y_offset_min self._m_has_field_y_offset_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_y_offset_min', None) @property def has_field_chase_stop_distance(self): if hasattr(self, '_m_has_field_chase_stop_distance'): return self._m_has_field_chase_stop_distance self._m_has_field_chase_stop_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_chase_stop_distance', None) class ConfigAiCombatSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_combat_phases: self.combat_phases = Output.DictOfEnumConfigAiCombatPhaseArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_combat_role: self.combat_role = Output.EnumConfigAiCombatRole(self._io, self, self._root) if self.has_field_broadcast_fear_on_death: self.broadcast_fear_on_death = self._io.read_u1() @property def has_field_combat_phases(self): if hasattr(self, '_m_has_field_combat_phases'): return self._m_has_field_combat_phases self._m_has_field_combat_phases = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_combat_phases', None) @property def has_field_combat_role(self): if hasattr(self, '_m_has_field_combat_role'): return self._m_has_field_combat_role self._m_has_field_combat_role = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_combat_role', None) @property def has_field_broadcast_fear_on_death(self): if hasattr(self, '_m_has_field_broadcast_fear_on_death'): return self._m_has_field_broadcast_fear_on_death self._m_has_field_broadcast_fear_on_death = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_broadcast_fear_on_death', None) class MpPlayLevelTextDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) class ArrayOfEnumUgcRayTriggerDirectionTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumUgcRayTriggerDirectionType(self._io, self, self._root)) class AttachModifierToHpPercentMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigLuaAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_invoke: self.invoke = self._io.read_u1() if self.has_field_invoke_alias: self.invoke_alias = AuxTypes.String(self._io, self, self._root) if self.has_field_invoke_param: self.invoke_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_invoke_alias(self): if hasattr(self, '_m_has_field_invoke_alias'): return self._m_has_field_invoke_alias self._m_has_field_invoke_alias = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_invoke_alias', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_invoke_param(self): if hasattr(self, '_m_has_field_invoke_param'): return self._m_has_field_invoke_param self._m_has_field_invoke_param = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_invoke_param', None) @property def has_field_invoke(self): if hasattr(self, '_m_has_field_invoke'): return self._m_has_field_invoke self._m_has_field_invoke = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_invoke', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfConfigCustomLevelRoomExtraDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCustomLevelRoomExtraData(self._io, self, self._root)) class DictOfAuxTypesStringConfigLcGadgetIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigLcGadgetIntee(self._io, self, self._root)) class ConfigTrackBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_destroy_when_target_die: self.destroy_when_target_die = self._io.read_u1() if self.has_field_trace_on_y_axis: self.trace_on_y_axis = self._io.read_u1() @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def has_field_destroy_when_target_die(self): if hasattr(self, '_m_has_field_destroy_when_target_die'): return self._m_has_field_destroy_when_target_die self._m_has_field_destroy_when_target_die = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_destroy_when_target_die', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def has_field_trace_on_y_axis(self): if hasattr(self, '_m_has_field_trace_on_y_axis'): return self._m_has_field_trace_on_y_axis self._m_has_field_trace_on_y_axis = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_trace_on_y_axis', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) class ByBigTeamElementTypeSort(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ActionCompoundTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MatchCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumMatchLimitType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class ChessCardQualityTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfPropValConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.PropValConfig(self._io, self, self._root)) class ForgeRandomExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_forge_random_id: self.forge_random_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_random_items: self.main_random_items = Output.ArrayOfRandomItemConfigLengthS(self._io, self, self._root) @property def has_field_forge_random_id(self): if hasattr(self, '_m_has_field_forge_random_id'): return self._m_has_field_forge_random_id self._m_has_field_forge_random_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_forge_random_id', None) @property def has_field_main_random_items(self): if hasattr(self, '_m_has_field_main_random_items'): return self._m_has_field_main_random_items self._m_has_field_main_random_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_main_random_items', None) class ExhibitionScoreTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerSetCastShadow(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cast_shadow: self.cast_shadow = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_cast_shadow(self): if hasattr(self, '_m_has_field_cast_shadow'): return self._m_has_field_cast_shadow self._m_has_field_cast_shadow = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cast_shadow', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class NewActivityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetTriggerAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseGadgetTriggerAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) class DispConfigSpecialCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigSpecialCamera(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadgetSpecialCamera(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class GuideNavigationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfMultiBadmintonBulletLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.MultiBadmintonBullet(self._io, self, self._root)) class ConfigLevelPolygons(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_polygons: self.polygons = Output.ArrayOfConfigLevelPolygonLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_polygons(self): if hasattr(self, '_m_has_field_polygons'): return self._m_has_field_polygons self._m_has_field_polygons = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_polygons', None) class HomeWorldSpecialFurnitureExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSettingLevelValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_quality_resolution_percentage_map: self.quality_resolution_percentage_map = Output.DictOfAuxTypesStringAuxTypesVlqBase128LeS(self._io, self, self._root) if self.has_field_graphics_recommend_grades: self.graphics_recommend_grades = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_quality_resolution_percentage_map(self): if hasattr(self, '_m_has_field_quality_resolution_percentage_map'): return self._m_has_field_quality_resolution_percentage_map self._m_has_field_quality_resolution_percentage_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quality_resolution_percentage_map', None) @property def has_field_graphics_recommend_grades(self): if hasattr(self, '_m_has_field_graphics_recommend_grades'): return self._m_has_field_graphics_recommend_grades self._m_has_field_graphics_recommend_grades = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_graphics_recommend_grades', None) class EnumGuideHasAvatarType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideHasAvatarType, self.data.value) return getattr(self, '_m_value', None) class CookRecipeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_desc: self.effect_desc = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_food_type: self.food_type = Output.EnumCookFoodType(self._io, self, self._root) if self.has_field_cook_method: self.cook_method = Output.EnumCookMethodType(self._io, self, self._root) if self.has_field_is_default_unlocked: self.is_default_unlocked = self._io.read_u1() if self.has_field_max_proficiency: self.max_proficiency = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quality_output_vec: self.quality_output_vec = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_input_vec: self.input_vec = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_qte_param: self.qte_param = AuxTypes.String(self._io, self, self._root) if self.has_field_qte_quality_weight_vec: self.qte_quality_weight_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_effect_desc(self): if hasattr(self, '_m_has_field_effect_desc'): return self._m_has_field_effect_desc self._m_has_field_effect_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_effect_desc', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_max_proficiency(self): if hasattr(self, '_m_has_field_max_proficiency'): return self._m_has_field_max_proficiency self._m_has_field_max_proficiency = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_max_proficiency', None) @property def has_field_cook_method(self): if hasattr(self, '_m_has_field_cook_method'): return self._m_has_field_cook_method self._m_has_field_cook_method = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cook_method', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_is_default_unlocked(self): if hasattr(self, '_m_has_field_is_default_unlocked'): return self._m_has_field_is_default_unlocked self._m_has_field_is_default_unlocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_default_unlocked', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_quality_output_vec(self): if hasattr(self, '_m_has_field_quality_output_vec'): return self._m_has_field_quality_output_vec self._m_has_field_quality_output_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_quality_output_vec', None) @property def has_field_food_type(self): if hasattr(self, '_m_has_field_food_type'): return self._m_has_field_food_type self._m_has_field_food_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_food_type', None) @property def has_field_input_vec(self): if hasattr(self, '_m_has_field_input_vec'): return self._m_has_field_input_vec self._m_has_field_input_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_input_vec', None) @property def has_field_qte_param(self): if hasattr(self, '_m_has_field_qte_param'): return self._m_has_field_qte_param self._m_has_field_qte_param = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_qte_param', None) @property def has_field_qte_quality_weight_vec(self): if hasattr(self, '_m_has_field_qte_quality_weight_vec'): return self._m_has_field_qte_quality_weight_vec self._m_has_field_qte_quality_weight_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_qte_quality_weight_vec', None) class ActivitySalesmanDailyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCameraSplineTargetPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBasePath(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_targets: self.targets = Output.ArrayOfDispConfigCameraSplineBaseTargetLengthU(self._io, self, self._root) @property def has_field_targets(self): if hasattr(self, '_m_has_field_targets'): return self._m_has_field_targets self._m_has_field_targets = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_targets', None) @property def pos_curve(self): if hasattr(self, '_m_pos_curve'): return self._m_pos_curve self._m_pos_curve = self.base.pos_curve return getattr(self, '_m_pos_curve', None) @property def total_length(self): if hasattr(self, '_m_total_length'): return self._m_total_length self._m_total_length = self.base.total_length return getattr(self, '_m_total_length', None) class BlossomTalkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_id: self.refresh_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_talk_id: self.talk_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_refresh_id(self): if hasattr(self, '_m_has_field_refresh_id'): return self._m_has_field_refresh_id self._m_has_field_refresh_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_refresh_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_talk_id(self): if hasattr(self, '_m_has_field_talk_id'): return self._m_has_field_talk_id self._m_has_field_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_talk_id', None) class ConfigBornByTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigGadgetTouchAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigRegionalPlayVarData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_var_type: self.var_type = Output.EnumRegionalPlayVarType(self._io, self, self._root) if self.has_field_init_value: self.init_value = self._io.read_f4le() @property def has_field_var_type(self): if hasattr(self, '_m_has_field_var_type'): return self._m_has_field_var_type self._m_has_field_var_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_var_type', None) @property def has_field_init_value(self): if hasattr(self, '_m_has_field_init_value'): return self._m_has_field_init_value self._m_has_field_init_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_init_value', None) class DictOfAuxTypesVlqBase128LeSConfigAiLandingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiLandingData(self._io, self, self._root)) class ShareCdExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumConfigAiCombatRole(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ConfigAiCombatRole, self.data.value) return getattr(self, '_m_value', None) class EnumPointLocation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PointLocation, self.data.value) return getattr(self, '_m_value', None) class ActivityMistTrialLevelFactorExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_factor_row_text: self.factor_row_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entry_show_text: self.entry_show_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_in_game_show_text: self.in_game_show_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_factor_row_text(self): if hasattr(self, '_m_has_field_factor_row_text'): return self._m_has_field_factor_row_text self._m_has_field_factor_row_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_factor_row_text', None) @property def has_field_in_game_show_text(self): if hasattr(self, '_m_has_field_in_game_show_text'): return self._m_has_field_in_game_show_text self._m_has_field_in_game_show_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_in_game_show_text', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_entry_show_text(self): if hasattr(self, '_m_has_field_entry_show_text'): return self._m_has_field_entry_show_text self._m_has_field_entry_show_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_entry_show_text', None) class MarkOrderComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HideAvatarSkillMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_i_ds: self.skill_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_skill_i_ds(self): if hasattr(self, '_m_has_field_skill_i_ds'): return self._m_has_field_skill_i_ds self._m_has_field_skill_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_i_ds', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ChannellerSlabBuffEnergyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_level: self.avatar_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_single_energy: self.single_energy = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_energy: self.mp_energy = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_avatar_level(self): if hasattr(self, '_m_has_field_avatar_level'): return self._m_has_field_avatar_level self._m_has_field_avatar_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_level', None) @property def has_field_single_energy(self): if hasattr(self, '_m_has_field_single_energy'): return self._m_has_field_single_energy self._m_has_field_single_energy = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_single_energy', None) @property def has_field_mp_energy(self): if hasattr(self, '_m_has_field_mp_energy'): return self._m_has_field_mp_energy self._m_has_field_mp_energy = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_mp_energy', None) class DictOfAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigJob(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigJob(self._io, self, self._root)) class SceneVehicleSummonPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_vehicle_type: self.vehicle_type = Output.EnumVehicleType(self._io, self, self._root) if self.has_field_vehicle_gadget_id: self.vehicle_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born_point_list: self.born_point_list = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_born_rotate_list: self.born_rotate_list = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_vehicle_radius: self.vehicle_radius = self._io.read_f4le() if self.has_field_title_text_id: self.title_text_id = AuxTypes.String(self._io, self, self._root) if self.has_field_map_mark_type: self.map_mark_type = Output.EnumSceneVehicleSummonPointMapMarkType(self._io, self, self._root) @property def has_field_title_text_id(self): if hasattr(self, '_m_has_field_title_text_id'): return self._m_has_field_title_text_id self._m_has_field_title_text_id = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_title_text_id', None) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def has_field_vehicle_radius(self): if hasattr(self, '_m_has_field_vehicle_radius'): return self._m_has_field_vehicle_radius self._m_has_field_vehicle_radius = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_vehicle_radius', None) @property def has_field_vehicle_type(self): if hasattr(self, '_m_has_field_vehicle_type'): return self._m_has_field_vehicle_type self._m_has_field_vehicle_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_vehicle_type', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def has_field_born_rotate_list(self): if hasattr(self, '_m_has_field_born_rotate_list'): return self._m_has_field_born_rotate_list self._m_has_field_born_rotate_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_born_rotate_list', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def has_field_map_mark_type(self): if hasattr(self, '_m_has_field_map_mark_type'): return self._m_has_field_map_mark_type self._m_has_field_map_mark_type = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_map_mark_type', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_vehicle_gadget_id(self): if hasattr(self, '_m_has_field_vehicle_gadget_id'): return self._m_has_field_vehicle_gadget_id self._m_has_field_vehicle_gadget_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_vehicle_gadget_id', None) @property def has_field_born_point_list(self): if hasattr(self, '_m_has_field_born_point_list'): return self._m_has_field_born_point_list self._m_has_field_born_point_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_born_point_list', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class EquipAffixStart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cd: self.cd = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_equip_affix_data_id: self.equip_affix_data_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cd', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_equip_affix_data_id(self): if hasattr(self, '_m_has_field_equip_affix_data_id'): return self._m_has_field_equip_affix_data_id self._m_has_field_equip_affix_data_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_equip_affix_data_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class IrodoriMasterLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cutscene: self.cutscene = AuxTypes.String(self._io, self, self._root) if self.has_field_gallery_ability_group_index: self.gallery_ability_group_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trial_avatar_list: self.trial_avatar_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_trial_avatar_list(self): if hasattr(self, '_m_has_field_trial_avatar_list'): return self._m_has_field_trial_avatar_list self._m_has_field_trial_avatar_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_trial_avatar_list', None) @property def has_field_cutscene(self): if hasattr(self, '_m_has_field_cutscene'): return self._m_has_field_cutscene self._m_has_field_cutscene = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cutscene', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_gallery_ability_group_index(self): if hasattr(self, '_m_has_field_gallery_ability_group_index'): return self._m_has_field_gallery_ability_group_index self._m_has_field_gallery_ability_group_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_gallery_ability_group_index', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_watcher_list', None) class EnumSectrPlatformType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SectrPlatformType, self.data.value) return getattr(self, '_m_value', None) class QuestAcceptionMarkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigRecordEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigRecordActorBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_animator_info: self.animator_info = Output.ConfigRecordAnimatorInfo(self._io, self, self._root) if self.has_field_renderer_params: self.renderer_params = Output.ConfigRecordRendererParameters(self._io, self, self._root) if self.has_field_material_params: self.material_params = Output.ConfigRecordMaterialParameters(self._io, self, self._root) if self.has_field_ragdoll_params: self.ragdoll_params = Output.ConfigRecordRagdollParameters(self._io, self, self._root) if self.has_field_emo_params: self.emo_params = Output.ConfigRecordEmoParameters(self._io, self, self._root) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def has_field_ragdoll_params(self): if hasattr(self, '_m_has_field_ragdoll_params'): return self._m_has_field_ragdoll_params self._m_has_field_ragdoll_params = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ragdoll_params', None) @property def has_field_animator_info(self): if hasattr(self, '_m_has_field_animator_info'): return self._m_has_field_animator_info self._m_has_field_animator_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_animator_info', None) @property def serial_id(self): if hasattr(self, '_m_serial_id'): return self._m_serial_id self._m_serial_id = self.base.serial_id return getattr(self, '_m_serial_id', None) @property def has_field_renderer_params(self): if hasattr(self, '_m_has_field_renderer_params'): return self._m_has_field_renderer_params self._m_has_field_renderer_params = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_renderer_params', None) @property def scale(self): if hasattr(self, '_m_scale'): return self._m_scale self._m_scale = self.base.scale return getattr(self, '_m_scale', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_emo_params(self): if hasattr(self, '_m_has_field_emo_params'): return self._m_has_field_emo_params self._m_has_field_emo_params = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_emo_params', None) @property def has_field_material_params(self): if hasattr(self, '_m_has_field_material_params'): return self._m_has_field_material_params self._m_has_field_material_params = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_material_params', None) class ConfigHomeworldDjinnInfoDefaultSave(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pos: self.pos = Output.Vector(self._io, self, self._root) if self.has_field_rot: self.rot = Output.Vector(self._io, self, self._root) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pos', None) @property def has_field_rot(self): if hasattr(self, '_m_has_field_rot'): return self._m_has_field_rot self._m_has_field_rot = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rot', None) class OpenStateCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBattleFervorUpdateTriggerByAttackTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorUpdateTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_cd: self.cd = self._io.read_f4le() @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tags', None) @property def has_field_cd(self): if hasattr(self, '_m_has_field_cd'): return self._m_has_field_cd self._m_has_field_cd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def delta_value(self): if hasattr(self, '_m_delta_value'): return self._m_delta_value self._m_delta_value = self.base.delta_value return getattr(self, '_m_delta_value', None) class ConfigMusicTrueCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicCondition(self._io, self, self._root) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class DispConfigRegionalPlayBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigRegionalPlayBase(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigRegionalPlayMichiaeMatsuri(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigRegionalPlayLightStone(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ArrayOfConfigRegionalPlayVarDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRegionalPlayVarData(self._io, self, self._root)) class ConfigMonsterAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCharacterAudio(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_random_variant_switch_group: self.random_variant_switch_group = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_random_variant_switch_values: self.random_variant_switch_values = Output.ArrayOfConfigWwiseStringLengthU(self._io, self, self._root) @property def has_field_random_variant_switch_values(self): if hasattr(self, '_m_has_field_random_variant_switch_values'): return self._m_has_field_random_variant_switch_values self._m_has_field_random_variant_switch_values = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_random_variant_switch_values', None) @property def destroy_event(self): if hasattr(self, '_m_destroy_event'): return self._m_destroy_event self._m_destroy_event = self.base.destroy_event return getattr(self, '_m_destroy_event', None) @property def anim_audio(self): if hasattr(self, '_m_anim_audio'): return self._m_anim_audio self._m_anim_audio = self.base.anim_audio return getattr(self, '_m_anim_audio', None) @property def has_field_random_variant_switch_group(self): if hasattr(self, '_m_has_field_random_variant_switch_group'): return self._m_has_field_random_variant_switch_group self._m_has_field_random_variant_switch_group = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_random_variant_switch_group', None) @property def disable_event(self): if hasattr(self, '_m_disable_event'): return self._m_disable_event self._m_disable_event = self.base.disable_event return getattr(self, '_m_disable_event', None) @property def enable_event(self): if hasattr(self, '_m_enable_event'): return self._m_enable_event self._m_enable_event = self.base.enable_event return getattr(self, '_m_enable_event', None) @property def init_event(self): if hasattr(self, '_m_init_event'): return self._m_init_event self._m_init_event = self.base.init_event return getattr(self, '_m_init_event', None) class SectrCityOffsetInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_city_name_hash: self.city_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_offset_info_list: self.offset_info_list = Output.ArrayOfSectrCityLevelTagOffsetInfoLengthU(self._io, self, self._root) @property def has_field_city_name_hash(self): if hasattr(self, '_m_has_field_city_name_hash'): return self._m_has_field_city_name_hash self._m_has_field_city_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_city_name_hash', None) @property def has_field_offset_info_list(self): if hasattr(self, '_m_has_field_offset_info_list'): return self._m_has_field_offset_info_list self._m_has_field_offset_info_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_offset_info_list', None) class DictOfEnumShadowQualityConfigShadowQualitySetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumShadowQualityConfigShadowQualitySetting(self._io, self, self._root)) class SignInCondConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumSignInCondType(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param_list', None) class HomeWorldShopSubTagExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigBattleFervorFactor(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigBattleFervorFactor(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigBattleFervorFactorByTrigger(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigBattleFervorFactorByMonster(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class CutsceneIndexTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCookMethodType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CookMethodType, self.data.value) return getattr(self, '_m_value', None) class EnumParamLogicType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ParamLogicType, self.data.value) return getattr(self, '_m_value', None) class ReputationExploreExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_explore_id: self.explore_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_explore_progress: self.explore_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_condition_text: self.condition_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_explore_progress(self): if hasattr(self, '_m_has_field_explore_progress'): return self._m_has_field_explore_progress self._m_has_field_explore_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_explore_progress', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_condition_text(self): if hasattr(self, '_m_has_field_condition_text'): return self._m_has_field_condition_text self._m_has_field_condition_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_condition_text', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_city_id', None) @property def has_field_explore_id(self): if hasattr(self, '_m_has_field_explore_id'): return self._m_has_field_explore_id self._m_has_field_explore_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_explore_id', None) class KvpOfDictEnumPerfRatingCategoryAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumPerfRatingCategory(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class UiInteractExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfAudioSettingSliderPostVoiceItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioSettingSliderPostVoiceItem(self._io, self, self._root)) class AudioWeatherProperties(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_state_value: self.state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_music_state_value: self.music_state_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_switch_value: self.switch_value = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_rtpc_value: self.rtpc_value = self._io.read_f4le() if self.has_field_surface_override: self.surface_override = AuxTypes.String(self._io, self, self._root) @property def has_field_state_value(self): if hasattr(self, '_m_has_field_state_value'): return self._m_has_field_state_value self._m_has_field_state_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_state_value', None) @property def has_field_music_state_value(self): if hasattr(self, '_m_has_field_music_state_value'): return self._m_has_field_music_state_value self._m_has_field_music_state_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_music_state_value', None) @property def has_field_surface_override(self): if hasattr(self, '_m_has_field_surface_override'): return self._m_has_field_surface_override self._m_has_field_surface_override = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_surface_override', None) @property def has_field_rtpc_value(self): if hasattr(self, '_m_has_field_rtpc_value'): return self._m_has_field_rtpc_value self._m_has_field_rtpc_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_rtpc_value', None) @property def has_field_switch_value(self): if hasattr(self, '_m_has_field_switch_value'): return self._m_has_field_switch_value self._m_has_field_switch_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_switch_value', None) class BanEntityMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_ban: self.is_ban = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_is_ban(self): if hasattr(self, '_m_has_field_is_ban'): return self._m_has_field_is_ban self._m_has_field_is_ban = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_ban', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumDocumentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DocumentType, self.data.value) return getattr(self, '_m_value', None) class EnumReactionTriggerType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReactionTriggerType, self.data.value) return getattr(self, '_m_value', None) class ConfigAbilityPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_target: self.target = Output.EnumAbilityTargetting(self._io, self, self._root) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target', None) class EnumDraftInviteType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DraftInviteType, self.data.value) return getattr(self, '_m_value', None) class FishBaitFeature(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_feature_tag: self.feature_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = self._io.read_f4le() if self.has_field_bonus_range: self.bonus_range = self._io.read_f4le() @property def has_field_feature_tag(self): if hasattr(self, '_m_has_field_feature_tag'): return self._m_has_field_feature_tag self._m_has_field_feature_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_feature_tag', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_bonus_range(self): if hasattr(self, '_m_has_field_bonus_range'): return self._m_has_field_bonus_range self._m_has_field_bonus_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_bonus_range', None) class FleurFairDungeonStatExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stat_type: self.stat_type = Output.EnumFleurFairDungeonStatType(self._io, self, self._root) if self.has_field_stat_param_list: self.stat_param_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_ordering_type: self.ordering_type = Output.EnumOrderingType(self._io, self, self._root) if self.has_field_stat_method: self.stat_method = Output.EnumFleurFairDungeonStatMethod(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_stat_param_list(self): if hasattr(self, '_m_has_field_stat_param_list'): return self._m_has_field_stat_param_list self._m_has_field_stat_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stat_param_list', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_ordering_type(self): if hasattr(self, '_m_has_field_ordering_type'): return self._m_has_field_ordering_type self._m_has_field_ordering_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_ordering_type', None) @property def has_field_stat_type(self): if hasattr(self, '_m_has_field_stat_type'): return self._m_has_field_stat_type self._m_has_field_stat_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stat_type', None) @property def has_field_stat_method(self): if hasattr(self, '_m_has_field_stat_method'): return self._m_has_field_stat_method self._m_has_field_stat_method = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_stat_method', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ShowGadgetBubble(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_content: self.content = AuxTypes.String(self._io, self, self._root) if self.has_field_distance: self.distance = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_distance', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_duration', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_content', None) class ByGlobalPosToGround(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_pos: self.global_pos = AuxTypes.String(self._io, self, self._root) if self.has_field_to_ground_height: self.to_ground_height = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_to_water: self.to_water = self._io.read_u1() @property def has_field_to_ground_height(self): if hasattr(self, '_m_has_field_to_ground_height'): return self._m_has_field_to_ground_height self._m_has_field_to_ground_height = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_ground_height', None) @property def has_field_to_water(self): if hasattr(self, '_m_has_field_to_water'): return self._m_has_field_to_water self._m_has_field_to_water = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_to_water', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def has_field_global_pos(self): if hasattr(self, '_m_has_field_global_pos'): return self._m_has_field_global_pos self._m_has_field_global_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_pos', None) class EnumInvestigationMonsterMapMarkCreateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InvestigationMonsterMapMarkCreateType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_cd_max: self.cd_max = self._io.read_f4le() if self.has_field_cd_min: self.cd_min = self._io.read_f4le() if self.has_field_distance_from_born: self.distance_from_born = self._io.read_f4le() if self.has_field_distance_from_current_min: self.distance_from_current_min = self._io.read_f4le() if self.has_field_distance_from_current_max: self.distance_from_current_max = self._io.read_f4le() if self.has_field_move_type: self.move_type = Output.EnumAiBasicMoveType(self._io, self, self._root) @property def has_field_cd_max(self): if hasattr(self, '_m_has_field_cd_max'): return self._m_has_field_cd_max self._m_has_field_cd_max = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cd_max', None) @property def has_field_distance_from_current_min(self): if hasattr(self, '_m_has_field_distance_from_current_min'): return self._m_has_field_distance_from_current_min self._m_has_field_distance_from_current_min = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_distance_from_current_min', None) @property def has_field_distance_from_born(self): if hasattr(self, '_m_has_field_distance_from_born'): return self._m_has_field_distance_from_born self._m_has_field_distance_from_born = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_distance_from_born', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_distance_from_current_max(self): if hasattr(self, '_m_has_field_distance_from_current_max'): return self._m_has_field_distance_from_current_max self._m_has_field_distance_from_current_max = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_distance_from_current_max', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_move_type', None) @property def has_field_cd_min(self): if hasattr(self, '_m_has_field_cd_min'): return self._m_has_field_cd_min self._m_has_field_cd_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_cd_min', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class EnumInterActionTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InterActionTargetType, self.data.value) return getattr(self, '_m_value', None) class CurLocalAvatarMixinV2(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class WeaponExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_weapon_type: self.weapon_type = Output.EnumWeaponType(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_material_type: self.material_type = Output.EnumWeaponMaterialType(self._io, self, self._root) if self.has_field_elem_type: self.elem_type = Output.EnumElementType(self._io, self, self._root) if self.has_field_is_gold: self.is_gold = self._io.read_u1() if self.has_field_weapon_base_exp: self.weapon_base_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_affix: self.skill_affix = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_awaken_material: self.awaken_material = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weapon_prop: self.weapon_prop = Output.ArrayOfWeaponPropertyLengthS(self._io, self, self._root) if self.has_field_awaken_texture: self.awaken_texture = AuxTypes.String(self._io, self, self._root) if self.has_field_awaken_light_map_texture: self.awaken_light_map_texture = AuxTypes.String(self._io, self, self._root) if self.has_field_awaken_icon: self.awaken_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_un_rotate: self.un_rotate = self._io.read_u1() if self.has_field_weapon_promote_id: self.weapon_promote_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_id: self.story_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_awaken_costs: self.awaken_costs = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gacha_card_name_hash: self.gacha_card_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enhance_rule: self.enhance_rule = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_destroy_rule: self.destroy_rule = Output.EnumMaterialDestroyType(self._io, self, self._root) if self.has_field_destroy_return_material: self.destroy_return_material = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_destroy_return_material_count: self.destroy_return_material_count = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_initial_lock_state: self.initial_lock_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_material_type(self): if hasattr(self, '_m_has_field_material_type'): return self._m_has_field_material_type self._m_has_field_material_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_material_type', None) @property def has_field_destroy_rule(self): if hasattr(self, '_m_has_field_destroy_rule'): return self._m_has_field_destroy_rule self._m_has_field_destroy_rule = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_destroy_rule', None) @property def has_field_weapon_prop(self): if hasattr(self, '_m_has_field_weapon_prop'): return self._m_has_field_weapon_prop self._m_has_field_weapon_prop = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_weapon_prop', None) @property def has_field_awaken_icon(self): if hasattr(self, '_m_has_field_awaken_icon'): return self._m_has_field_awaken_icon self._m_has_field_awaken_icon = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_awaken_icon', None) @property def has_field_destroy_return_material(self): if hasattr(self, '_m_has_field_destroy_return_material'): return self._m_has_field_destroy_return_material self._m_has_field_destroy_return_material = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_destroy_return_material', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_story_id(self): if hasattr(self, '_m_has_field_story_id'): return self._m_has_field_story_id self._m_has_field_story_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_story_id', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_dropable', None) @property def has_field_weapon_type(self): if hasattr(self, '_m_has_field_weapon_type'): return self._m_has_field_weapon_type self._m_has_field_weapon_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_weapon_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_use_level', None) @property def has_field_skill_affix(self): if hasattr(self, '_m_has_field_skill_affix'): return self._m_has_field_skill_affix self._m_has_field_skill_affix = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_skill_affix', None) @property def has_field_elem_type(self): if hasattr(self, '_m_has_field_elem_type'): return self._m_has_field_elem_type self._m_has_field_elem_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_elem_type', None) @property def has_field_initial_lock_state(self): if hasattr(self, '_m_has_field_initial_lock_state'): return self._m_has_field_initial_lock_state self._m_has_field_initial_lock_state = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_initial_lock_state', None) @property def has_field_awaken_material(self): if hasattr(self, '_m_has_field_awaken_material'): return self._m_has_field_awaken_material self._m_has_field_awaken_material = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_awaken_material', None) @property def has_field_is_gold(self): if hasattr(self, '_m_has_field_is_gold'): return self._m_has_field_is_gold self._m_has_field_is_gold = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_gold', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = ((self.bit_field.length.value >= (4 + 1)) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_un_rotate(self): if hasattr(self, '_m_has_field_un_rotate'): return self._m_has_field_un_rotate self._m_has_field_un_rotate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_un_rotate', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_enhance_rule(self): if hasattr(self, '_m_has_field_enhance_rule'): return self._m_has_field_enhance_rule self._m_has_field_enhance_rule = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_enhance_rule', None) @property def has_field_weapon_base_exp(self): if hasattr(self, '_m_has_field_weapon_base_exp'): return self._m_has_field_weapon_base_exp self._m_has_field_weapon_base_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_weapon_base_exp', None) @property def has_field_gacha_card_name_hash(self): if hasattr(self, '_m_has_field_gacha_card_name_hash'): return self._m_has_field_gacha_card_name_hash self._m_has_field_gacha_card_name_hash = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_gacha_card_name_hash', None) @property def has_field_awaken_light_map_texture(self): if hasattr(self, '_m_has_field_awaken_light_map_texture'): return self._m_has_field_awaken_light_map_texture self._m_has_field_awaken_light_map_texture = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_awaken_light_map_texture', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_item_type', None) @property def has_field_weapon_promote_id(self): if hasattr(self, '_m_has_field_weapon_promote_id'): return self._m_has_field_weapon_promote_id self._m_has_field_weapon_promote_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_weapon_promote_id', None) @property def has_field_awaken_costs(self): if hasattr(self, '_m_has_field_awaken_costs'): return self._m_has_field_awaken_costs self._m_has_field_awaken_costs = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_awaken_costs', None) @property def has_field_destroy_return_material_count(self): if hasattr(self, '_m_has_field_destroy_return_material_count'): return self._m_has_field_destroy_return_material_count self._m_has_field_destroy_return_material_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_destroy_return_material_count', None) @property def has_field_awaken_texture(self): if hasattr(self, '_m_has_field_awaken_texture'): return self._m_has_field_awaken_texture self._m_has_field_awaken_texture = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_awaken_texture', None) class FlightDailyInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_watcher: self.watcher = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_watcher(self): if hasattr(self, '_m_has_field_watcher'): return self._m_has_field_watcher self._m_has_field_watcher = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_watcher', None) class ArrayOfEnumWidgetOccupyTagLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumWidgetOccupyTag(self._io, self, self._root)) class EnumRegionalPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionalPlayType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigWeekendDjinnLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigWeekendDjinn(self._io, self, self._root)) class ConfigGadgetPredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMonsterSkin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigSkin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skin_colors: self.skin_colors = Output.ArrayOfSkinColorLengthU(self._io, self, self._root) @property def has_field_skin_colors(self): if hasattr(self, '_m_has_field_skin_colors'): return self._m_has_field_skin_colors self._m_has_field_skin_colors = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skin_colors', None) class ArrayOfConfigHomeworldGroupUnitLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldGroupUnit(self._io, self, self._root)) class HuntingMonsterFinishTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionByDamageReceivedParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FetterCharacterCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_level: self.fetter_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_fetter_level(self): if hasattr(self, '_m_has_field_fetter_level'): return self._m_has_field_fetter_level self._m_has_field_fetter_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_fetter_level', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward_id', None) class ActivityChessMapExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_chess_map_id: self.chess_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_name: self.map_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_tips: self.unlock_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_icon_path: self.map_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_build_gear_limit: self.build_gear_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entry_point_id: self.entry_point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_teach_map: self.is_teach_map = self._io.read_u1() if self.has_field_prev_map_id: self.prev_map_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show: self.show = self._io.read_u1() if self.has_field_entrance_point_id_list: self.entrance_point_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_exit_point_id_list: self.exit_point_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_entry_point_id(self): if hasattr(self, '_m_has_field_entry_point_id'): return self._m_has_field_entry_point_id self._m_has_field_entry_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_entry_point_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_map_name(self): if hasattr(self, '_m_has_field_map_name'): return self._m_has_field_map_name self._m_has_field_map_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_map_name', None) @property def has_field_exit_point_id_list(self): if hasattr(self, '_m_has_field_exit_point_id_list'): return self._m_has_field_exit_point_id_list self._m_has_field_exit_point_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_exit_point_id_list', None) @property def has_field_is_teach_map(self): if hasattr(self, '_m_has_field_is_teach_map'): return self._m_has_field_is_teach_map self._m_has_field_is_teach_map = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_is_teach_map', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_show', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_entrance_point_id_list(self): if hasattr(self, '_m_has_field_entrance_point_id_list'): return self._m_has_field_entrance_point_id_list self._m_has_field_entrance_point_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_entrance_point_id_list', None) @property def has_field_prev_map_id(self): if hasattr(self, '_m_has_field_prev_map_id'): return self._m_has_field_prev_map_id self._m_has_field_prev_map_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_prev_map_id', None) @property def has_field_chess_map_id(self): if hasattr(self, '_m_has_field_chess_map_id'): return self._m_has_field_chess_map_id self._m_has_field_chess_map_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_chess_map_id', None) @property def has_field_unlock_tips(self): if hasattr(self, '_m_has_field_unlock_tips'): return self._m_has_field_unlock_tips self._m_has_field_unlock_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_tips', None) @property def has_field_map_icon_path(self): if hasattr(self, '_m_has_field_map_icon_path'): return self._m_has_field_map_icon_path self._m_has_field_map_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_map_icon_path', None) @property def has_field_build_gear_limit(self): if hasattr(self, '_m_has_field_build_gear_limit'): return self._m_has_field_build_gear_limit self._m_has_field_build_gear_limit = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_build_gear_limit', None) class OpennessFuncTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumConfigAiCombatPhaseArrayOfAuxTypesVlqBase128LeSLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumConfigAiCombatPhaseArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root)) class ConfigGuideOpenUiCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() if self.has_field_active_list: self.active_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_page_type: self.page_type = Output.EnumGuidePageType(self._io, self, self._root) @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_context_name', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_page_type(self): if hasattr(self, '_m_has_field_page_type'): return self._m_has_field_page_type self._m_has_field_page_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_page_type', None) @property def has_field_active_list(self): if hasattr(self, '_m_has_field_active_list'): return self._m_has_field_active_list self._m_has_field_active_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_active_list', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class ConfigAnimationAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_on_transition_in: self.on_transition_in = Output.ArrayOfConfigStateAudioEventLengthU(self._io, self, self._root) if self.has_field_on_transition_out: self.on_transition_out = Output.ArrayOfConfigStateAudioEventLengthU(self._io, self, self._root) if self.has_field_recurrent_speeches: self.recurrent_speeches = Output.DictOfAuxTypesStringConfigAnimationRecurrentSpeech(self._io, self, self._root) @property def has_field_on_transition_in(self): if hasattr(self, '_m_has_field_on_transition_in'): return self._m_has_field_on_transition_in self._m_has_field_on_transition_in = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_transition_in', None) @property def has_field_on_transition_out(self): if hasattr(self, '_m_has_field_on_transition_out'): return self._m_has_field_on_transition_out self._m_has_field_on_transition_out = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_on_transition_out', None) @property def has_field_recurrent_speeches(self): if hasattr(self, '_m_has_field_recurrent_speeches'): return self._m_has_field_recurrent_speeches self._m_has_field_recurrent_speeches = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_recurrent_speeches', None) class ChallengeRecordTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigHomeworldFurnitureEnviroComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_on_day: self.on_day = self._io.read_u1() if self.has_field_type: self.type = self._io.read_u1() if self.has_field_disable_dist: self.disable_dist = self._io.read_f4le() @property def has_field_on_day(self): if hasattr(self, '_m_has_field_on_day'): return self._m_has_field_on_day self._m_has_field_on_day = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_day', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_disable_dist(self): if hasattr(self, '_m_has_field_disable_dist'): return self._m_has_field_disable_dist self._m_has_field_disable_dist = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_disable_dist', None) class ActivityUpAvatarExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CalcDvalinS04rebornPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ReunionPrivilegeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_daily_num: self.daily_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_total_num: self.total_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_privilege_type: self.privilege_type = Output.ArrayOfReunionPrivilegeConfigLengthS(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_daily_num(self): if hasattr(self, '_m_has_field_daily_num'): return self._m_has_field_daily_num self._m_has_field_daily_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_daily_num', None) @property def has_field_total_num(self): if hasattr(self, '_m_has_field_total_num'): return self._m_has_field_total_num self._m_has_field_total_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_total_num', None) @property def has_field_privilege_type(self): if hasattr(self, '_m_has_field_privilege_type'): return self._m_has_field_privilege_type self._m_has_field_privilege_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_privilege_type', None) class AnimatorRecordState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_short_name_hash: self.short_name_hash = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_state_length: self.state_length = self._io.read_f4le() if self.has_field_normalized_time: self.normalized_time = self._io.read_f4le() @property def has_field_short_name_hash(self): if hasattr(self, '_m_has_field_short_name_hash'): return self._m_has_field_short_name_hash self._m_has_field_short_name_hash = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_short_name_hash', None) @property def has_field_state_length(self): if hasattr(self, '_m_has_field_state_length'): return self._m_has_field_state_length self._m_has_field_state_length = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_state_length', None) @property def has_field_normalized_time(self): if hasattr(self, '_m_has_field_normalized_time'): return self._m_has_field_normalized_time self._m_has_field_normalized_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_normalized_time', None) class ArrayOfSectrLayerGroupLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrLayerGroup(self._io, self, self._root)) class HomeWorldSpecialFurnitureExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_furniture_id: self.furniture_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_furniture_id(self): if hasattr(self, '_m_has_field_furniture_id'): return self._m_has_field_furniture_id self._m_has_field_furniture_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_furniture_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gadget_id', None) class HomeWorldExtraFurnitureExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicShifter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_target_song_id: self.target_song_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_root_condition_id: self.root_condition_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_target_song_id(self): if hasattr(self, '_m_has_field_target_song_id'): return self._m_has_field_target_song_id self._m_has_field_target_song_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_song_id', None) @property def has_field_root_condition_id(self): if hasattr(self, '_m_has_field_root_condition_id'): return self._m_has_field_root_condition_id self._m_has_field_root_condition_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_root_condition_id', None) class ConfigMoveFollowNpc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMoveFollowTarget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_quest_id', None) class ArrayOfConfigMusicShifterLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMusicShifter(self._io, self, self._root)) class MonsterDescribeExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title_id: self.title_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_special_name_lab_id: self.special_name_lab_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_special_name_lab_id(self): if hasattr(self, '_m_has_field_special_name_lab_id'): return self._m_has_field_special_name_lab_id self._m_has_field_special_name_lab_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_special_name_lab_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_title_id(self): if hasattr(self, '_m_has_field_title_id'): return self._m_has_field_title_id self._m_has_field_title_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_title_id', None) class PhotographTaskLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_price_tier', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_shop_type', None) class TriggerCreateGadgetToEquipPart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_equip_part: self.equip_part = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_gadget_id', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_equip_part(self): if hasattr(self, '_m_has_field_equip_part'): return self._m_has_field_equip_part self._m_has_field_equip_part = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_equip_part', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class SignInCondExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_list: self.cond_list = Output.ArrayOfSignInCondConfigLengthS(self._io, self, self._root) if self.has_field_total_day_count: self.total_day_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_cond_list(self): if hasattr(self, '_m_has_field_cond_list'): return self._m_has_field_cond_list self._m_has_field_cond_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond_list', None) @property def has_field_total_day_count(self): if hasattr(self, '_m_has_field_total_day_count'): return self._m_has_field_total_day_count self._m_has_field_total_day_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_total_day_count', None) class SceneBuildingTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByStageIsReadyTemp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class WindSeedSpawnerMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_enable: self.refresh_enable = self._io.read_u1() if self.has_field_spawner_radius: self.spawner_radius = self._io.read_f4le() if self.has_field_spawner_height_angle: self.spawner_height_angle = self._io.read_f4le() if self.has_field_spawner_area_angle: self.spawner_area_angle = self._io.read_f4le() if self.has_field_min_distance_to_avatar: self.min_distance_to_avatar = self._io.read_f4le() if self.has_field_move_suppress_speed: self.move_suppress_speed = self._io.read_f4le() if self.has_field_move_refresh_angle_freeze: self.move_refresh_angle_freeze = self._io.read_f4le() if self.has_field_move_refresh_angle_slow: self.move_refresh_angle_slow = self._io.read_f4le() if self.has_field_min_num_per_spawn: self.min_num_per_spawn = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_num_per_spawn: self.max_num_per_spawn = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_swap_num_per_spawn: self.max_swap_num_per_spawn = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_separate_range: self.min_separate_range = self._io.read_f4le() if self.has_field_max_separate_range: self.max_separate_range = self._io.read_f4le() if self.has_field_remove_seed_distance: self.remove_seed_distance = self._io.read_f4le() if self.has_field_refresh_meter_per_meter: self.refresh_meter_per_meter = self._io.read_f4le() if self.has_field_refresh_meter_per_second: self.refresh_meter_per_second = self._io.read_f4le() if self.has_field_refresh_meter_per_dist_remove: self.refresh_meter_per_dist_remove = self._io.read_f4le() if self.has_field_refresh_meter_max: self.refresh_meter_max = self._io.read_f4le() if self.has_field_wind_force_modifier: self.wind_force_modifier = AuxTypes.String(self._io, self, self._root) if self.has_field_wind_explode_modifier: self.wind_explode_modifier = AuxTypes.String(self._io, self, self._root) if self.has_field_wind_bullet_ability: self.wind_bullet_ability = AuxTypes.String(self._io, self, self._root) if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_spawn_num_array: self.spawn_num_array = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_seed_gadget_id: self.seed_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_init_signal_strength: self.init_signal_strength = self._io.read_f4le() if self.has_field_trigger_signal_strength: self.trigger_signal_strength = self._io.read_f4le() if self.has_field_signal_decay_speed: self.signal_decay_speed = self._io.read_f4le() if self.has_field_mutiple_range: self.mutiple_range = self._io.read_f4le() if self.has_field_catch_seed_range: self.catch_seed_range = self._io.read_f4le() @property def has_field_wind_explode_modifier(self): if hasattr(self, '_m_has_field_wind_explode_modifier'): return self._m_has_field_wind_explode_modifier self._m_has_field_wind_explode_modifier = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_wind_explode_modifier', None) @property def has_field_refresh_meter_per_meter(self): if hasattr(self, '_m_has_field_refresh_meter_per_meter'): return self._m_has_field_refresh_meter_per_meter self._m_has_field_refresh_meter_per_meter = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_refresh_meter_per_meter', None) @property def has_field_spawn_num_array(self): if hasattr(self, '_m_has_field_spawn_num_array'): return self._m_has_field_spawn_num_array self._m_has_field_spawn_num_array = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_spawn_num_array', None) @property def has_field_wind_force_modifier(self): if hasattr(self, '_m_has_field_wind_force_modifier'): return self._m_has_field_wind_force_modifier self._m_has_field_wind_force_modifier = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_wind_force_modifier', None) @property def has_field_catch_seed_range(self): if hasattr(self, '_m_has_field_catch_seed_range'): return self._m_has_field_catch_seed_range self._m_has_field_catch_seed_range = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_catch_seed_range', None) @property def has_field_min_separate_range(self): if hasattr(self, '_m_has_field_min_separate_range'): return self._m_has_field_min_separate_range self._m_has_field_min_separate_range = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_min_separate_range', None) @property def has_field_move_suppress_speed(self): if hasattr(self, '_m_has_field_move_suppress_speed'): return self._m_has_field_move_suppress_speed self._m_has_field_move_suppress_speed = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_move_suppress_speed', None) @property def has_field_init_signal_strength(self): if hasattr(self, '_m_has_field_init_signal_strength'): return self._m_has_field_init_signal_strength self._m_has_field_init_signal_strength = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_init_signal_strength', None) @property def has_field_trigger_signal_strength(self): if hasattr(self, '_m_has_field_trigger_signal_strength'): return self._m_has_field_trigger_signal_strength self._m_has_field_trigger_signal_strength = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_trigger_signal_strength', None) @property def has_field_refresh_meter_per_dist_remove(self): if hasattr(self, '_m_has_field_refresh_meter_per_dist_remove'): return self._m_has_field_refresh_meter_per_dist_remove self._m_has_field_refresh_meter_per_dist_remove = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_refresh_meter_per_dist_remove', None) @property def has_field_min_distance_to_avatar(self): if hasattr(self, '_m_has_field_min_distance_to_avatar'): return self._m_has_field_min_distance_to_avatar self._m_has_field_min_distance_to_avatar = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_min_distance_to_avatar', None) @property def has_field_spawner_area_angle(self): if hasattr(self, '_m_has_field_spawner_area_angle'): return self._m_has_field_spawner_area_angle self._m_has_field_spawner_area_angle = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_spawner_area_angle', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_spawner_radius(self): if hasattr(self, '_m_has_field_spawner_radius'): return self._m_has_field_spawner_radius self._m_has_field_spawner_radius = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_spawner_radius', None) @property def has_field_refresh_enable(self): if hasattr(self, '_m_has_field_refresh_enable'): return self._m_has_field_refresh_enable self._m_has_field_refresh_enable = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_refresh_enable', None) @property def has_field_max_swap_num_per_spawn(self): if hasattr(self, '_m_has_field_max_swap_num_per_spawn'): return self._m_has_field_max_swap_num_per_spawn self._m_has_field_max_swap_num_per_spawn = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_max_swap_num_per_spawn', None) @property def has_field_remove_seed_distance(self): if hasattr(self, '_m_has_field_remove_seed_distance'): return self._m_has_field_remove_seed_distance self._m_has_field_remove_seed_distance = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_remove_seed_distance', None) @property def has_field_refresh_meter_max(self): if hasattr(self, '_m_has_field_refresh_meter_max'): return self._m_has_field_refresh_meter_max self._m_has_field_refresh_meter_max = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_refresh_meter_max', None) @property def has_field_min_num_per_spawn(self): if hasattr(self, '_m_has_field_min_num_per_spawn'): return self._m_has_field_min_num_per_spawn self._m_has_field_min_num_per_spawn = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_min_num_per_spawn', None) @property def has_field_spawner_height_angle(self): if hasattr(self, '_m_has_field_spawner_height_angle'): return self._m_has_field_spawner_height_angle self._m_has_field_spawner_height_angle = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_spawner_height_angle', None) @property def has_field_max_num_per_spawn(self): if hasattr(self, '_m_has_field_max_num_per_spawn'): return self._m_has_field_max_num_per_spawn self._m_has_field_max_num_per_spawn = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_max_num_per_spawn', None) @property def has_field_move_refresh_angle_freeze(self): if hasattr(self, '_m_has_field_move_refresh_angle_freeze'): return self._m_has_field_move_refresh_angle_freeze self._m_has_field_move_refresh_angle_freeze = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_move_refresh_angle_freeze', None) @property def has_field_signal_decay_speed(self): if hasattr(self, '_m_has_field_signal_decay_speed'): return self._m_has_field_signal_decay_speed self._m_has_field_signal_decay_speed = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_signal_decay_speed', None) @property def has_field_seed_gadget_id(self): if hasattr(self, '_m_has_field_seed_gadget_id'): return self._m_has_field_seed_gadget_id self._m_has_field_seed_gadget_id = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_seed_gadget_id', None) @property def has_field_move_refresh_angle_slow(self): if hasattr(self, '_m_has_field_move_refresh_angle_slow'): return self._m_has_field_move_refresh_angle_slow self._m_has_field_move_refresh_angle_slow = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_move_refresh_angle_slow', None) @property def has_field_mutiple_range(self): if hasattr(self, '_m_has_field_mutiple_range'): return self._m_has_field_mutiple_range self._m_has_field_mutiple_range = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_mutiple_range', None) @property def has_field_max_separate_range(self): if hasattr(self, '_m_has_field_max_separate_range'): return self._m_has_field_max_separate_range self._m_has_field_max_separate_range = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_max_separate_range', None) @property def has_field_wind_bullet_ability(self): if hasattr(self, '_m_has_field_wind_bullet_ability'): return self._m_has_field_wind_bullet_ability self._m_has_field_wind_bullet_ability = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_wind_bullet_ability', None) @property def has_field_refresh_meter_per_second(self): if hasattr(self, '_m_has_field_refresh_meter_per_second'): return self._m_has_field_refresh_meter_per_second self._m_has_field_refresh_meter_per_second = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_refresh_meter_per_second', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DigGroupLinkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TaskIdComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityGachaStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TutorialExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MpPlaySettleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideWidgetContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_path: self.path = AuxTypes.String(self._io, self, self._root) if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_hint_info: self.hint_info = AuxTypes.String(self._io, self, self._root) if self.has_field_widght_info: self.widght_info = AuxTypes.String(self._io, self, self._root) if self.has_field_warning_info: self.warning_info = AuxTypes.String(self._io, self, self._root) if self.has_field_white_context_list: self.white_context_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_action_info_list: self.action_info_list = Output.ArrayOfEnumInputActionTypeLengthU(self._io, self, self._root) if self.has_field_input_hint_list: self.input_hint_list = Output.ArrayOfConfigInputHintLengthU(self._io, self, self._root) if self.has_field_widght_info_pos: self.widght_info_pos = Output.EnumWidgetInfoPos(self._io, self, self._root) if self.has_field_mask_type: self.mask_type = Output.EnumMaskGuideType(self._io, self, self._root) if self.has_field_mask_pass_easy_touch: self.mask_pass_easy_touch = self._io.read_u1() if self.has_field_type: self.type = Output.EnumButtonGuideType(self._io, self, self._root) if self.has_field_x_offset: self.x_offset = self._io.read_f4le() if self.has_field_y_offset: self.y_offset = self._io.read_f4le() if self.has_field_hint_offset: self.hint_offset = self._io.read_f4le() if self.has_field_special: self.special = Output.EnumGuideWidgetSpecialType(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() if self.has_field_value_str: self.value_str = AuxTypes.String(self._io, self, self._root) if self.has_field_page_type: self.page_type = Output.EnumGuidePageType(self._io, self, self._root) if self.has_field_mask_index: self.mask_index = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_keep_scale: self.keep_scale = self._io.read_u1() if self.has_field_general_condition_type: self.general_condition_type = Output.EnumGuideGeneralConditionType(self._io, self, self._root) if self.has_field_general_condition_val: self.general_condition_val = self._io.read_u1() @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_context_name', None) @property def has_field_general_condition_val(self): if hasattr(self, '_m_has_field_general_condition_val'): return self._m_has_field_general_condition_val self._m_has_field_general_condition_val = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_general_condition_val', None) @property def has_field_y_offset(self): if hasattr(self, '_m_has_field_y_offset'): return self._m_has_field_y_offset self._m_has_field_y_offset = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_y_offset', None) @property def has_field_hint_info(self): if hasattr(self, '_m_has_field_hint_info'): return self._m_has_field_hint_info self._m_has_field_hint_info = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_hint_info', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_mask_type(self): if hasattr(self, '_m_has_field_mask_type'): return self._m_has_field_mask_type self._m_has_field_mask_type = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_mask_type', None) @property def has_field_mask_pass_easy_touch(self): if hasattr(self, '_m_has_field_mask_pass_easy_touch'): return self._m_has_field_mask_pass_easy_touch self._m_has_field_mask_pass_easy_touch = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_mask_pass_easy_touch', None) @property def has_field_general_condition_type(self): if hasattr(self, '_m_has_field_general_condition_type'): return self._m_has_field_general_condition_type self._m_has_field_general_condition_type = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_general_condition_type', None) @property def has_field_widght_info_pos(self): if hasattr(self, '_m_has_field_widght_info_pos'): return self._m_has_field_widght_info_pos self._m_has_field_widght_info_pos = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_widght_info_pos', None) @property def has_field_page_type(self): if hasattr(self, '_m_has_field_page_type'): return self._m_has_field_page_type self._m_has_field_page_type = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_page_type', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_path(self): if hasattr(self, '_m_has_field_path'): return self._m_has_field_path self._m_has_field_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_path', None) @property def has_field_warning_info(self): if hasattr(self, '_m_has_field_warning_info'): return self._m_has_field_warning_info self._m_has_field_warning_info = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_warning_info', None) @property def has_field_hint_offset(self): if hasattr(self, '_m_has_field_hint_offset'): return self._m_has_field_hint_offset self._m_has_field_hint_offset = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_hint_offset', None) @property def has_field_mask_index(self): if hasattr(self, '_m_has_field_mask_index'): return self._m_has_field_mask_index self._m_has_field_mask_index = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_mask_index', None) @property def has_field_widght_info(self): if hasattr(self, '_m_has_field_widght_info'): return self._m_has_field_widght_info self._m_has_field_widght_info = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_widght_info', None) @property def has_field_white_context_list(self): if hasattr(self, '_m_has_field_white_context_list'): return self._m_has_field_white_context_list self._m_has_field_white_context_list = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_white_context_list', None) @property def has_field_x_offset(self): if hasattr(self, '_m_has_field_x_offset'): return self._m_has_field_x_offset self._m_has_field_x_offset = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_x_offset', None) @property def has_field_action_info_list(self): if hasattr(self, '_m_has_field_action_info_list'): return self._m_has_field_action_info_list self._m_has_field_action_info_list = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_action_info_list', None) @property def has_field_keep_scale(self): if hasattr(self, '_m_has_field_keep_scale'): return self._m_has_field_keep_scale self._m_has_field_keep_scale = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_keep_scale', None) @property def has_field_value_str(self): if hasattr(self, '_m_has_field_value_str'): return self._m_has_field_value_str self._m_has_field_value_str = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_value_str', None) @property def has_field_input_hint_list(self): if hasattr(self, '_m_has_field_input_hint_list'): return self._m_has_field_input_hint_list self._m_has_field_input_hint_list = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_input_hint_list', None) @property def has_field_special(self): if hasattr(self, '_m_has_field_special'): return self._m_has_field_special self._m_has_field_special = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_special', None) class MonsterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_boss: self.boss = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_monster: self.monster = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_boss(self): if hasattr(self, '_m_has_field_boss'): return self._m_has_field_boss self._m_has_field_boss = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_boss', None) @property def has_field_monster(self): if hasattr(self, '_m_has_field_monster'): return self._m_has_field_monster self._m_has_field_monster = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster', None) class ConfigGadgetDamageByAttackValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseGadgetTriggerAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_attack_info: self.attack_info = Output.ConfigAttackInfo(self._io, self, self._root) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) @property def has_field_attack_info(self): if hasattr(self, '_m_has_field_attack_info'): return self._m_has_field_attack_info self._m_has_field_attack_info = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attack_info', None) class ItemUseOpComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AudioSettingSliderPostVoiceItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_voice_trigger_identity: self.voice_trigger_identity = Output.VoiceTriggerIdentity(self._io, self, self._root) if self.has_field_repeat_count: self.repeat_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_voice_trigger_identity(self): if hasattr(self, '_m_has_field_voice_trigger_identity'): return self._m_has_field_voice_trigger_identity self._m_has_field_voice_trigger_identity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_voice_trigger_identity', None) @property def has_field_repeat_count(self): if hasattr(self, '_m_has_field_repeat_count'): return self._m_has_field_repeat_count self._m_has_field_repeat_count = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_repeat_count', None) class PlayerLevelLockExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RelyOnElementMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_type: self.element_type = Output.EnumElementType(self._io, self, self._root) @property def has_field_element_type(self): if hasattr(self, '_m_has_field_element_type'): return self._m_has_field_element_type self._m_has_field_element_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigLevelNpcBornPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_born_pos_list: self.born_pos_list = Output.ArrayOfConfigNpcBornPosLengthU(self._io, self, self._root) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def has_field_born_pos_list(self): if hasattr(self, '_m_has_field_born_pos_list'): return self._m_has_field_born_pos_list self._m_has_field_born_pos_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born_pos_list', None) class DictOfAuxTypesStringPlayerCustomOptionConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringPlayerCustomOptionConfig(self._io, self, self._root)) class SoundBankUnloadPolicyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicBooleanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class GachaTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PointMapVisibilityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiFishingPretendBitesSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFishingPretendBitesData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFishingPretendBitesData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ByTargetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_type: self.target_type = Output.EnumAbilityTargetting(self._io, self, self._root) if self.has_field_is_target: self.is_target = self._io.read_u1() @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_is_target(self): if hasattr(self, '_m_has_field_is_target'): return self._m_has_field_is_target self._m_has_field_is_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_target', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ReliquaryLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCutsceneDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigDialogGroup(self._io, self, self._root) @property def talk_id(self): if hasattr(self, '_m_talk_id'): return self._m_talk_id self._m_talk_id = self.base.talk_id return getattr(self, '_m_talk_id', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def dialog_list(self): if hasattr(self, '_m_dialog_list'): return self._m_dialog_list self._m_dialog_list = self.base.dialog_list return getattr(self, '_m_dialog_list', None) class ReputationCityExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AnimatorParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_floats: self.floats = Output.ArrayOfAnimatorFloatLengthU(self._io, self, self._root) if self.has_field_ints: self.ints = Output.ArrayOfAnimatorIntLengthU(self._io, self, self._root) if self.has_field_bools: self.bools = Output.ArrayOfAnimatorBoolLengthU(self._io, self, self._root) if self.has_field_triggers: self.triggers = Output.ArrayOfAnimatorTriggerLengthU(self._io, self, self._root) @property def has_field_floats(self): if hasattr(self, '_m_has_field_floats'): return self._m_has_field_floats self._m_has_field_floats = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_floats', None) @property def has_field_ints(self): if hasattr(self, '_m_has_field_ints'): return self._m_has_field_ints self._m_has_field_ints = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ints', None) @property def has_field_bools(self): if hasattr(self, '_m_has_field_bools'): return self._m_has_field_bools self._m_has_field_bools = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_bools', None) @property def has_field_triggers(self): if hasattr(self, '_m_has_field_triggers'): return self._m_has_field_triggers self._m_has_field_triggers = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_triggers', None) class MailExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopInteractionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class LanV2fireworksFactorDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_factor_id: self.factor_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_perfect_range: self.perfect_range = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_factor_length: self.factor_length = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumFireworksReformParamType(self._io, self, self._root) if self.has_field_color_range: self.color_range = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_perfect_range(self): if hasattr(self, '_m_has_field_perfect_range'): return self._m_has_field_perfect_range self._m_has_field_perfect_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_perfect_range', None) @property def has_field_color_range(self): if hasattr(self, '_m_has_field_color_range'): return self._m_has_field_color_range self._m_has_field_color_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_color_range', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_factor_length(self): if hasattr(self, '_m_has_field_factor_length'): return self._m_has_field_factor_length self._m_has_field_factor_length = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_factor_length', None) @property def has_field_factor_id(self): if hasattr(self, '_m_has_field_factor_id'): return self._m_has_field_factor_id self._m_has_field_factor_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_factor_id', None) class AttachToPlayStageMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_stage: self.stage = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_stage(self): if hasattr(self, '_m_has_field_stage'): return self._m_has_field_stage self._m_has_field_stage = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_stage', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class MatchNewRuleSpecifiedExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_enable: self.is_enable = self._io.read_u1() if self.has_field_player_level_boundary: self.player_level_boundary = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_boundary: self.time_boundary = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_is_enable(self): if hasattr(self, '_m_has_field_is_enable'): return self._m_has_field_is_enable self._m_has_field_is_enable = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_enable', None) @property def has_field_player_level_boundary(self): if hasattr(self, '_m_has_field_player_level_boundary'): return self._m_has_field_player_level_boundary self._m_has_field_player_level_boundary = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_player_level_boundary', None) @property def has_field_time_boundary(self): if hasattr(self, '_m_has_field_time_boundary'): return self._m_has_field_time_boundary self._m_has_field_time_boundary = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_time_boundary', None) class OutputControlConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChapterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CoopPointTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumGuideWidgetSpecialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideWidgetSpecialType, self.data.value) return getattr(self, '_m_value', None) class AvatarEnterViewBias(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_sphere_bias_pole: self.sphere_bias_pole = self._io.read_f4le() if self.has_field_sphere_bias_elev: self.sphere_bias_elev = self._io.read_f4le() if self.has_field_sphere_radius: self.sphere_radius = self._io.read_f4le() if self.has_field_post_forward_pole_delta_angle: self.post_forward_pole_delta_angle = self._io.read_f4le() if self.has_field_post_forward_elev_delta_angle: self.post_forward_elev_delta_angle = self._io.read_f4le() if self.has_field_duration_in_normal_state: self.duration_in_normal_state = self._io.read_f4le() if self.has_field_lock_zoom: self.lock_zoom = self._io.read_u1() if self.has_field_lock_reset_back: self.lock_reset_back = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_sphere_bias_elev(self): if hasattr(self, '_m_has_field_sphere_bias_elev'): return self._m_has_field_sphere_bias_elev self._m_has_field_sphere_bias_elev = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sphere_bias_elev', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_duration_in_normal_state(self): if hasattr(self, '_m_has_field_duration_in_normal_state'): return self._m_has_field_duration_in_normal_state self._m_has_field_duration_in_normal_state = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_duration_in_normal_state', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def has_field_post_forward_elev_delta_angle(self): if hasattr(self, '_m_has_field_post_forward_elev_delta_angle'): return self._m_has_field_post_forward_elev_delta_angle self._m_has_field_post_forward_elev_delta_angle = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_post_forward_elev_delta_angle', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_sphere_radius(self): if hasattr(self, '_m_has_field_sphere_radius'): return self._m_has_field_sphere_radius self._m_has_field_sphere_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_sphere_radius', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_sphere_bias_pole(self): if hasattr(self, '_m_has_field_sphere_bias_pole'): return self._m_has_field_sphere_bias_pole self._m_has_field_sphere_bias_pole = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sphere_bias_pole', None) @property def has_field_post_forward_pole_delta_angle(self): if hasattr(self, '_m_has_field_post_forward_pole_delta_angle'): return self._m_has_field_post_forward_pole_delta_angle self._m_has_field_post_forward_pole_delta_angle = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_post_forward_pole_delta_angle', None) @property def has_field_lock_zoom(self): if hasattr(self, '_m_has_field_lock_zoom'): return self._m_has_field_lock_zoom self._m_has_field_lock_zoom = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_lock_zoom', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_lock_reset_back(self): if hasattr(self, '_m_has_field_lock_reset_back'): return self._m_has_field_lock_reset_back self._m_has_field_lock_reset_back = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_lock_reset_back', None) class EnumOpResponder(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpResponder, self.data.value) return getattr(self, '_m_value', None) class ArrayOfInputActionEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.InputActionEvent(self._io, self, self._root)) class ConfigCombat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_property: self.property = Output.ConfigCombatProperty(self._io, self, self._root) if self.has_field_be_hit: self.be_hit = Output.ConfigCombatBeHit(self._io, self, self._root) if self.has_field_combat_lock: self.combat_lock = Output.ConfigCombatLock(self._io, self, self._root) if self.has_field_die: self.die = Output.ConfigDie(self._io, self, self._root) if self.has_field_anim_events: self.anim_events = Output.DictOfAuxTypesStringConfigAttackEvent(self._io, self, self._root) if self.has_field_summon: self.summon = Output.ConfigSummon(self._io, self, self._root) if self.has_field_simulate_physics: self.simulate_physics = Output.ConfigSimulatePhysics(self._io, self, self._root) @property def has_field_die(self): if hasattr(self, '_m_has_field_die'): return self._m_has_field_die self._m_has_field_die = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_die', None) @property def has_field_simulate_physics(self): if hasattr(self, '_m_has_field_simulate_physics'): return self._m_has_field_simulate_physics self._m_has_field_simulate_physics = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_simulate_physics', None) @property def has_field_combat_lock(self): if hasattr(self, '_m_has_field_combat_lock'): return self._m_has_field_combat_lock self._m_has_field_combat_lock = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_combat_lock', None) @property def has_field_anim_events(self): if hasattr(self, '_m_has_field_anim_events'): return self._m_has_field_anim_events self._m_has_field_anim_events = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_anim_events', None) @property def has_field_be_hit(self): if hasattr(self, '_m_has_field_be_hit'): return self._m_has_field_be_hit self._m_has_field_be_hit = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_be_hit', None) @property def has_field_property(self): if hasattr(self, '_m_has_field_property'): return self._m_has_field_property self._m_has_field_property = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_property', None) @property def has_field_summon(self): if hasattr(self, '_m_has_field_summon'): return self._m_has_field_summon self._m_has_field_summon = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_summon', None) class ProductConcertPackageDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_original_price_tier: self.original_price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_discount_rate: self.discount_rate = self._io.read_f4le() if self.has_field_show_id: self.show_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_replace_mcoin_num: self.replace_mcoin_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_name: self.item_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_desc: self.item_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sort_level: self.sort_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_time: self.begin_time = AuxTypes.String(self._io, self, self._root) if self.has_field_end_time: self.end_time = AuxTypes.String(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_end_time(self): if hasattr(self, '_m_has_field_end_time'): return self._m_has_field_end_time self._m_has_field_end_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_end_time', None) @property def has_field_discount_rate(self): if hasattr(self, '_m_has_field_discount_rate'): return self._m_has_field_discount_rate self._m_has_field_discount_rate = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_discount_rate', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_sort_level(self): if hasattr(self, '_m_has_field_sort_level'): return self._m_has_field_sort_level self._m_has_field_sort_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_sort_level', None) @property def has_field_original_price_tier(self): if hasattr(self, '_m_has_field_original_price_tier'): return self._m_has_field_original_price_tier self._m_has_field_original_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_original_price_tier', None) @property def has_field_replace_mcoin_num(self): if hasattr(self, '_m_has_field_replace_mcoin_num'): return self._m_has_field_replace_mcoin_num self._m_has_field_replace_mcoin_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_replace_mcoin_num', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_begin_time(self): if hasattr(self, '_m_has_field_begin_time'): return self._m_has_field_begin_time self._m_has_field_begin_time = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_begin_time', None) @property def has_field_item_desc(self): if hasattr(self, '_m_has_field_item_desc'): return self._m_has_field_item_desc self._m_has_field_item_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_item_desc', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_show_id(self): if hasattr(self, '_m_has_field_show_id'): return self._m_has_field_show_id self._m_has_field_show_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_show_id', None) @property def has_field_item_name(self): if hasattr(self, '_m_has_field_item_name'): return self._m_has_field_item_name self._m_has_field_item_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_item_name', None) class LocalizationExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_asset_type: self.asset_type = Output.EnumLocalizationAssetType(self._io, self, self._root) if self.has_field_default_path: self.default_path = AuxTypes.String(self._io, self, self._root) if self.has_field_sc_path: self.sc_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tc_path: self.tc_path = AuxTypes.String(self._io, self, self._root) if self.has_field_en_path: self.en_path = AuxTypes.String(self._io, self, self._root) if self.has_field_kr_path: self.kr_path = AuxTypes.String(self._io, self, self._root) if self.has_field_jp_path: self.jp_path = AuxTypes.String(self._io, self, self._root) if self.has_field_es_path: self.es_path = AuxTypes.String(self._io, self, self._root) if self.has_field_fr_path: self.fr_path = AuxTypes.String(self._io, self, self._root) if self.has_field_id_path: self.id_path = AuxTypes.String(self._io, self, self._root) if self.has_field_pt_path: self.pt_path = AuxTypes.String(self._io, self, self._root) if self.has_field_ru_path: self.ru_path = AuxTypes.String(self._io, self, self._root) if self.has_field_th_path: self.th_path = AuxTypes.String(self._io, self, self._root) if self.has_field_vi_path: self.vi_path = AuxTypes.String(self._io, self, self._root) if self.has_field_de_path: self.de_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tr_path: self.tr_path = AuxTypes.String(self._io, self, self._root) if self.has_field_it_path: self.it_path = AuxTypes.String(self._io, self, self._root) @property def has_field_es_path(self): if hasattr(self, '_m_has_field_es_path'): return self._m_has_field_es_path self._m_has_field_es_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_es_path', None) @property def has_field_tc_path(self): if hasattr(self, '_m_has_field_tc_path'): return self._m_has_field_tc_path self._m_has_field_tc_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tc_path', None) @property def has_field_en_path(self): if hasattr(self, '_m_has_field_en_path'): return self._m_has_field_en_path self._m_has_field_en_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_en_path', None) @property def has_field_asset_type(self): if hasattr(self, '_m_has_field_asset_type'): return self._m_has_field_asset_type self._m_has_field_asset_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_asset_type', None) @property def has_field_sc_path(self): if hasattr(self, '_m_has_field_sc_path'): return self._m_has_field_sc_path self._m_has_field_sc_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sc_path', None) @property def has_field_jp_path(self): if hasattr(self, '_m_has_field_jp_path'): return self._m_has_field_jp_path self._m_has_field_jp_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_jp_path', None) @property def has_field_tr_path(self): if hasattr(self, '_m_has_field_tr_path'): return self._m_has_field_tr_path self._m_has_field_tr_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_tr_path', None) @property def has_field_vi_path(self): if hasattr(self, '_m_has_field_vi_path'): return self._m_has_field_vi_path self._m_has_field_vi_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_vi_path', None) @property def has_field_kr_path(self): if hasattr(self, '_m_has_field_kr_path'): return self._m_has_field_kr_path self._m_has_field_kr_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_kr_path', None) @property def has_field_th_path(self): if hasattr(self, '_m_has_field_th_path'): return self._m_has_field_th_path self._m_has_field_th_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_th_path', None) @property def has_field_default_path(self): if hasattr(self, '_m_has_field_default_path'): return self._m_has_field_default_path self._m_has_field_default_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_default_path', None) @property def has_field_id_path(self): if hasattr(self, '_m_has_field_id_path'): return self._m_has_field_id_path self._m_has_field_id_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_id_path', None) @property def has_field_pt_path(self): if hasattr(self, '_m_has_field_pt_path'): return self._m_has_field_pt_path self._m_has_field_pt_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_pt_path', None) @property def has_field_ru_path(self): if hasattr(self, '_m_has_field_ru_path'): return self._m_has_field_ru_path self._m_has_field_ru_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_ru_path', None) @property def has_field_de_path(self): if hasattr(self, '_m_has_field_de_path'): return self._m_has_field_de_path self._m_has_field_de_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_de_path', None) @property def has_field_it_path(self): if hasattr(self, '_m_has_field_it_path'): return self._m_has_field_it_path self._m_has_field_it_path = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_it_path', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_fr_path(self): if hasattr(self, '_m_has_field_fr_path'): return self._m_has_field_fr_path self._m_has_field_fr_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_fr_path', None) class ContextActionSelectSceneMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_icon_type: self.icon_type = Output.EnumMarkIconType(self._io, self, self._root) if self.has_field_city_id: self.city_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_ids: self.scene_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_icon_type(self): if hasattr(self, '_m_has_field_icon_type'): return self._m_has_field_icon_type self._m_has_field_icon_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_icon_type', None) @property def has_field_city_id(self): if hasattr(self, '_m_has_field_city_id'): return self._m_has_field_city_id self._m_has_field_city_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_city_id', None) @property def has_field_scene_ids(self): if hasattr(self, '_m_has_field_scene_ids'): return self._m_has_field_scene_ids self._m_has_field_scene_ids = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scene_ids', None) class ConfigDirectionByWorld(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornDirectionType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_eular_angles: self.eular_angles = Output.Vector(self._io, self, self._root) @property def angle_offset(self): if hasattr(self, '_m_angle_offset'): return self._m_angle_offset self._m_angle_offset = self.base.angle_offset return getattr(self, '_m_angle_offset', None) @property def max_angle(self): if hasattr(self, '_m_max_angle'): return self._m_max_angle self._m_max_angle = self.base.max_angle return getattr(self, '_m_max_angle', None) @property def max_angle_type(self): if hasattr(self, '_m_max_angle_type'): return self._m_max_angle_type self._m_max_angle_type = self.base.max_angle_type return getattr(self, '_m_max_angle_type', None) @property def use_correct_dir(self): if hasattr(self, '_m_use_correct_dir'): return self._m_use_correct_dir self._m_use_correct_dir = self.base.use_correct_dir return getattr(self, '_m_use_correct_dir', None) @property def has_field_eular_angles(self): if hasattr(self, '_m_has_field_eular_angles'): return self._m_has_field_eular_angles self._m_has_field_eular_angles = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_eular_angles', None) @property def angle_offset_correct(self): if hasattr(self, '_m_angle_offset_correct'): return self._m_angle_offset_correct self._m_angle_offset_correct = self.base.angle_offset_correct return getattr(self, '_m_angle_offset_correct', None) @property def random_angle_ver(self): if hasattr(self, '_m_random_angle_ver'): return self._m_random_angle_ver self._m_random_angle_ver = self.base.random_angle_ver return getattr(self, '_m_random_angle_ver', None) @property def random_angle_hor(self): if hasattr(self, '_m_random_angle_hor'): return self._m_random_angle_hor self._m_random_angle_hor = self.base.random_angle_hor return getattr(self, '_m_random_angle_hor', None) class AudioPlatformMoveSettings(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_move_type: self.move_type = Output.EnumAudioPlatformMoveType(self._io, self, self._root) if self.has_field_move_start_event: self.move_start_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_move_stop_event: self.move_stop_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_rotate_start_event: self.rotate_start_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_rotate_stop_event: self.rotate_stop_event = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_linear_velocity_threshold: self.linear_velocity_threshold = self._io.read_f4le() if self.has_field_angular_velocity_threshold: self.angular_velocity_threshold = self._io.read_f4le() @property def has_field_angular_velocity_threshold(self): if hasattr(self, '_m_has_field_angular_velocity_threshold'): return self._m_has_field_angular_velocity_threshold self._m_has_field_angular_velocity_threshold = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_angular_velocity_threshold', None) @property def has_field_linear_velocity_threshold(self): if hasattr(self, '_m_has_field_linear_velocity_threshold'): return self._m_has_field_linear_velocity_threshold self._m_has_field_linear_velocity_threshold = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_linear_velocity_threshold', None) @property def has_field_move_type(self): if hasattr(self, '_m_has_field_move_type'): return self._m_has_field_move_type self._m_has_field_move_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_move_type', None) @property def has_field_move_stop_event(self): if hasattr(self, '_m_has_field_move_stop_event'): return self._m_has_field_move_stop_event self._m_has_field_move_stop_event = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_move_stop_event', None) @property def has_field_rotate_start_event(self): if hasattr(self, '_m_has_field_rotate_start_event'): return self._m_has_field_rotate_start_event self._m_has_field_rotate_start_event = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_rotate_start_event', None) @property def has_field_move_start_event(self): if hasattr(self, '_m_has_field_move_start_event'): return self._m_has_field_move_start_event self._m_has_field_move_start_event = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_move_start_event', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_rotate_stop_event(self): if hasattr(self, '_m_has_field_rotate_stop_event'): return self._m_has_field_rotate_stop_event self._m_has_field_rotate_stop_event = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_rotate_stop_event', None) class ConfigModifierStackingOption(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ability_special_name: self.ability_special_name = AuxTypes.String(self._io, self, self._root) if self.has_field_unique_modifier_condition: self.unique_modifier_condition = Output.EnumUniqueModifierCond(self._io, self, self._root) if self.has_field_max_modifier_num_for_multiple_type: self.max_modifier_num_for_multiple_type = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_enable_mixed_unique: self.enable_mixed_unique = self._io.read_u1() @property def has_field_ability_special_name(self): if hasattr(self, '_m_has_field_ability_special_name'): return self._m_has_field_ability_special_name self._m_has_field_ability_special_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_special_name', None) @property def has_field_unique_modifier_condition(self): if hasattr(self, '_m_has_field_unique_modifier_condition'): return self._m_has_field_unique_modifier_condition self._m_has_field_unique_modifier_condition = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_unique_modifier_condition', None) @property def has_field_max_modifier_num_for_multiple_type(self): if hasattr(self, '_m_has_field_max_modifier_num_for_multiple_type'): return self._m_has_field_max_modifier_num_for_multiple_type self._m_has_field_max_modifier_num_for_multiple_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_modifier_num_for_multiple_type', None) @property def has_field_enable_mixed_unique(self): if hasattr(self, '_m_has_field_enable_mixed_unique'): return self._m_has_field_enable_mixed_unique self._m_has_field_enable_mixed_unique = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_enable_mixed_unique', None) class RoguelikeShikigamiGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_config: self.effect_config = Output.RoguelikeEffectExcelConfig(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_effect_config(self): if hasattr(self, '_m_has_field_effect_config'): return self._m_has_field_effect_config self._m_has_field_effect_config = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_effect_config', None) class ContextConditionNot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_condition: self.condition = Output.DispContextCondition(self._io, self, self._root) @property def has_field_condition(self): if hasattr(self, '_m_has_field_condition'): return self._m_has_field_condition self._m_has_field_condition = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_condition', None) class ConfigMusicUInt32greaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigGuideFlyFailCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class AnimatorTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_set: self.is_set = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_is_set(self): if hasattr(self, '_m_has_field_is_set'): return self._m_has_field_is_set self._m_has_field_is_set = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_set', None) class MiracleRingDropExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigChest(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_born_locked_by_ability: self.born_locked_by_ability = self._io.read_u1() if self.has_field_open_effect: self.open_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_open_chest_vo: self.trigger_open_chest_vo = self._io.read_u1() @property def has_field_born_locked_by_ability(self): if hasattr(self, '_m_has_field_born_locked_by_ability'): return self._m_has_field_born_locked_by_ability self._m_has_field_born_locked_by_ability = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born_locked_by_ability', None) @property def has_field_open_effect(self): if hasattr(self, '_m_has_field_open_effect'): return self._m_has_field_open_effect self._m_has_field_open_effect = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_open_effect', None) @property def has_field_trigger_open_chest_vo(self): if hasattr(self, '_m_has_field_trigger_open_chest_vo'): return self._m_has_field_trigger_open_chest_vo self._m_has_field_trigger_open_chest_vo = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_trigger_open_chest_vo', None) class ConfigItanoCircusBulletMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBulletMove(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_itano_circus_start_angler: self.itano_circus_start_angler = self._io.read_f4le() if self.has_field_destroy_when_target_die: self.destroy_when_target_die = self._io.read_u1() if self.has_field_guidance_delay: self.guidance_delay = self._io.read_f4le() if self.has_field_guidance_speed_change: self.guidance_speed_change = self._io.read_u1() if self.has_field_guidance_min_angler_velocity: self.guidance_min_angler_velocity = self._io.read_f4le() if self.has_field_guidance_duration: self.guidance_duration = self._io.read_f4le() @property def acceleration_time(self): if hasattr(self, '_m_acceleration_time'): return self._m_acceleration_time self._m_acceleration_time = self.base.acceleration_time return getattr(self, '_m_acceleration_time', None) @property def min_speed(self): if hasattr(self, '_m_min_speed'): return self._m_min_speed self._m_min_speed = self.base.min_speed return getattr(self, '_m_min_speed', None) @property def has_field_destroy_when_target_die(self): if hasattr(self, '_m_has_field_destroy_when_target_die'): return self._m_has_field_destroy_when_target_die self._m_has_field_destroy_when_target_die = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_destroy_when_target_die', None) @property def has_field_guidance_min_angler_velocity(self): if hasattr(self, '_m_has_field_guidance_min_angler_velocity'): return self._m_has_field_guidance_min_angler_velocity self._m_has_field_guidance_min_angler_velocity = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_guidance_min_angler_velocity', None) @property def angler_velocity(self): if hasattr(self, '_m_angler_velocity'): return self._m_angler_velocity self._m_angler_velocity = self.base.angler_velocity return getattr(self, '_m_angler_velocity', None) @property def has_field_guidance_delay(self): if hasattr(self, '_m_has_field_guidance_delay'): return self._m_has_field_guidance_delay self._m_has_field_guidance_delay = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_guidance_delay', None) @property def sync_to_remote(self): if hasattr(self, '_m_sync_to_remote'): return self._m_sync_to_remote self._m_sync_to_remote = self.base.sync_to_remote return getattr(self, '_m_sync_to_remote', None) @property def max_speed(self): if hasattr(self, '_m_max_speed'): return self._m_max_speed self._m_max_speed = self.base.max_speed return getattr(self, '_m_max_speed', None) @property def blocked_by_monster_radius(self): if hasattr(self, '_m_blocked_by_monster_radius'): return self._m_blocked_by_monster_radius self._m_blocked_by_monster_radius = self.base.blocked_by_monster_radius return getattr(self, '_m_blocked_by_monster_radius', None) @property def update_angle(self): if hasattr(self, '_m_update_angle'): return self._m_update_angle self._m_update_angle = self.base.update_angle return getattr(self, '_m_update_angle', None) @property def can_born_in_water(self): if hasattr(self, '_m_can_born_in_water'): return self._m_can_born_in_water self._m_can_born_in_water = self.base.can_born_in_water return getattr(self, '_m_can_born_in_water', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def stick_to_ground(self): if hasattr(self, '_m_stick_to_ground'): return self._m_stick_to_ground self._m_stick_to_ground = self.base.stick_to_ground return getattr(self, '_m_stick_to_ground', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def speed(self): if hasattr(self, '_m_speed'): return self._m_speed self._m_speed = self.base.speed return getattr(self, '_m_speed', None) @property def acceleration(self): if hasattr(self, '_m_acceleration'): return self._m_acceleration self._m_acceleration = self.base.acceleration return getattr(self, '_m_acceleration', None) @property def delay(self): if hasattr(self, '_m_delay'): return self._m_delay self._m_delay = self.base.delay return getattr(self, '_m_delay', None) @property def has_field_guidance_speed_change(self): if hasattr(self, '_m_has_field_guidance_speed_change'): return self._m_has_field_guidance_speed_change self._m_has_field_guidance_speed_change = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_guidance_speed_change', None) @property def has_field_guidance_duration(self): if hasattr(self, '_m_has_field_guidance_duration'): return self._m_has_field_guidance_duration self._m_has_field_guidance_duration = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_guidance_duration', None) @property def has_field_itano_circus_start_angler(self): if hasattr(self, '_m_has_field_itano_circus_start_angler'): return self._m_has_field_itano_circus_start_angler self._m_has_field_itano_circus_start_angler = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_itano_circus_start_angler', None) class FireAvatarBeingHitAfterImage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_index: self.effect_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_index(self): if hasattr(self, '_m_has_field_effect_index'): return self._m_has_field_effect_index self._m_has_field_effect_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_index', None) class ArrayOfConfigMassiveElementTriggerActionLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMassiveElementTriggerAction(self._io, self, self._root)) class ConfigWidgetAttachAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_use_gadget_id: self.use_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def has_field_use_gadget_id(self): if hasattr(self, '_m_has_field_use_gadget_id'): return self._m_has_field_use_gadget_id self._m_has_field_use_gadget_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_use_gadget_id', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class ExhibitionDisplayCondParamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSceneObjState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SceneObjState, self.data.value) return getattr(self, '_m_value', None) class RoomWeatherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_id: self.room_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_profile_name: self.profile_name = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_room_id(self): if hasattr(self, '_m_has_field_room_id'): return self._m_has_field_room_id self._m_has_field_room_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_room_id', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_profile_name(self): if hasattr(self, '_m_has_field_profile_name'): return self._m_has_field_profile_name self._m_has_field_profile_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_profile_name', None) class ConfigBornByAttachPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attach_point_name: self.attach_point_name = AuxTypes.String(self._io, self, self._root) if self.has_field_attach_point_target_type: self.attach_point_target_type = Output.EnumAttachPointTargetType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def has_field_attach_point_target_type(self): if hasattr(self, '_m_has_field_attach_point_target_type'): return self._m_has_field_attach_point_target_type self._m_has_field_attach_point_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_attach_point_target_type', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def has_field_attach_point_name(self): if hasattr(self, '_m_has_field_attach_point_name'): return self._m_has_field_attach_point_name self._m_has_field_attach_point_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_point_name', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigEnvironmentZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_env_type: self.env_type = Output.EnumEnvironmentType(self._io, self, self._root) if self.has_field_point_vec: self.point_vec = Output.ArrayOfPoint2dLengthU(self._io, self, self._root) if self.has_field_bottom: self.bottom = self._io.read_f4le() if self.has_field_top: self.top = self._io.read_f4le() if self.has_field_is_use_height_range: self.is_use_height_range = self._io.read_u1() if self.has_field_animal_max_num: self.animal_max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_time: self.refresh_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_event_type_list: self.event_type_list = Output.ArrayOfEnumEnvZoneEventTypeLengthU(self._io, self, self._root) if self.has_field_task_content_type: self.task_content_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_task_type: self.task_type = Output.EnumRandTaskContentType(self._io, self, self._root) if self.has_field_task_id_list: self.task_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_center: self.center = Output.Point2d(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_zone_bit_type: self.zone_bit_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_choose_possible_point: self.choose_possible_point = self._io.read_u1() if self.has_field_possible_point_vec: self.possible_point_vec = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_random_quest_entrance_id_list: self.random_quest_entrance_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_task_id_list(self): if hasattr(self, '_m_has_field_task_id_list'): return self._m_has_field_task_id_list self._m_has_field_task_id_list = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_task_id_list', None) @property def has_field_task_type(self): if hasattr(self, '_m_has_field_task_type'): return self._m_has_field_task_type self._m_has_field_task_type = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_task_type', None) @property def has_field_center(self): if hasattr(self, '_m_has_field_center'): return self._m_has_field_center self._m_has_field_center = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_center', None) @property def has_field_env_type(self): if hasattr(self, '_m_has_field_env_type'): return self._m_has_field_env_type self._m_has_field_env_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_env_type', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_area_id', None) @property def has_field_bottom(self): if hasattr(self, '_m_has_field_bottom'): return self._m_has_field_bottom self._m_has_field_bottom = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_bottom', None) @property def has_field_zone_bit_type(self): if hasattr(self, '_m_has_field_zone_bit_type'): return self._m_has_field_zone_bit_type self._m_has_field_zone_bit_type = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_zone_bit_type', None) @property def has_field_choose_possible_point(self): if hasattr(self, '_m_has_field_choose_possible_point'): return self._m_has_field_choose_possible_point self._m_has_field_choose_possible_point = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_choose_possible_point', None) @property def has_field_event_type_list(self): if hasattr(self, '_m_has_field_event_type_list'): return self._m_has_field_event_type_list self._m_has_field_event_type_list = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_event_type_list', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_level', None) @property def has_field_random_quest_entrance_id_list(self): if hasattr(self, '_m_has_field_random_quest_entrance_id_list'): return self._m_has_field_random_quest_entrance_id_list self._m_has_field_random_quest_entrance_id_list = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_random_quest_entrance_id_list', None) @property def has_field_top(self): if hasattr(self, '_m_has_field_top'): return self._m_has_field_top self._m_has_field_top = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_top', None) @property def has_field_refresh_time(self): if hasattr(self, '_m_has_field_refresh_time'): return self._m_has_field_refresh_time self._m_has_field_refresh_time = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_refresh_time', None) @property def has_field_possible_point_vec(self): if hasattr(self, '_m_has_field_possible_point_vec'): return self._m_has_field_possible_point_vec self._m_has_field_possible_point_vec = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_possible_point_vec', None) @property def has_field_is_use_height_range(self): if hasattr(self, '_m_has_field_is_use_height_range'): return self._m_has_field_is_use_height_range self._m_has_field_is_use_height_range = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_is_use_height_range', None) @property def has_field_point_vec(self): if hasattr(self, '_m_has_field_point_vec'): return self._m_has_field_point_vec self._m_has_field_point_vec = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_point_vec', None) @property def has_field_task_content_type(self): if hasattr(self, '_m_has_field_task_content_type'): return self._m_has_field_task_content_type self._m_has_field_task_content_type = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_task_content_type', None) @property def has_field_animal_max_num(self): if hasattr(self, '_m_has_field_animal_max_num'): return self._m_has_field_animal_max_num self._m_has_field_animal_max_num = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_animal_max_num', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_index', None) class DictOfAuxTypesVlqBase128LeSConfigAiSurroundData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSurroundData(self._io, self, self._root)) class ClusterTriggerMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radius: self.radius = self._io.read_f4le() if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_action_queue: self.action_queue = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_id', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_action_queue(self): if hasattr(self, '_m_has_field_action_queue'): return self._m_has_field_action_queue self._m_has_field_action_queue = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_action_queue', None) @property def has_field_radius(self): if hasattr(self, '_m_has_field_radius'): return self._m_has_field_radius self._m_has_field_radius = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_radius', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_duration', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class GuideHasAvatarConTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMainPageDisableInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ui_disable_list: self.ui_disable_list = Output.ArrayOfEnumMainPageUiDisableTypeLengthU(self._io, self, self._root) if self.has_field_enabled_input_event_list: self.enabled_input_event_list = Output.ArrayOfEnumInputEventTypeLengthU(self._io, self, self._root) @property def has_field_ui_disable_list(self): if hasattr(self, '_m_has_field_ui_disable_list'): return self._m_has_field_ui_disable_list self._m_has_field_ui_disable_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_disable_list', None) @property def has_field_enabled_input_event_list(self): if hasattr(self, '_m_has_field_enabled_input_event_list'): return self._m_has_field_enabled_input_event_list self._m_has_field_enabled_input_event_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enabled_input_event_list', None) class CameraShakeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EmoRecordTypeEnumComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiBrownianMotionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiBrownianMotionData(self._io, self, self._root) class ConfigSpecialElementViewAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_open: self.is_open = self._io.read_u1() if self.has_field_effect_color: self.effect_color = Output.ColorVector(self._io, self, self._root) if self.has_field_effect_range: self.effect_range = self._io.read_f4le() if self.has_field_no_effect_alias_list: self.no_effect_alias_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_is_open(self): if hasattr(self, '_m_has_field_is_open'): return self._m_has_field_is_open self._m_has_field_is_open = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_open', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_effect_color(self): if hasattr(self, '_m_has_field_effect_color'): return self._m_has_field_effect_color self._m_has_field_effect_color = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_color', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_effect_range(self): if hasattr(self, '_m_has_field_effect_range'): return self._m_has_field_effect_range self._m_has_field_effect_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_effect_range', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_no_effect_alias_list(self): if hasattr(self, '_m_has_field_no_effect_alias_list'): return self._m_has_field_no_effect_alias_list self._m_has_field_no_effect_alias_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_no_effect_alias_list', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class TriggerAttackTargetMapEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_target_map_event: self.attack_target_map_event = Output.ConfigAttackTargetMapEvent(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_attack_target_map_event(self): if hasattr(self, '_m_has_field_attack_target_map_event'): return self._m_has_field_attack_target_map_event self._m_has_field_attack_target_map_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_target_map_event', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfEnumActionSlotTypeArrayOfConfigActionButtonLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumActionSlotTypeArrayOfConfigActionButtonLengthU(self._io, self, self._root)) class DungeonStateTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringDispContextAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispContextAction(self._io, self, self._root)) class ConfigWindSeed(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_athuority_radius: self.athuority_radius = self._io.read_f4le() @property def has_field_athuority_radius(self): if hasattr(self, '_m_has_field_athuority_radius'): return self._m_has_field_athuority_radius self._m_has_field_athuority_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_athuority_radius', None) class ConfigWorldArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id1: self.id1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id2: self.id2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_polygon_data: self.polygon_data = Output.ConfigPolygonArea(self._io, self, self._root) @property def has_field_id1(self): if hasattr(self, '_m_has_field_id1'): return self._m_has_field_id1 self._m_has_field_id1 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id1', None) @property def has_field_id2(self): if hasattr(self, '_m_has_field_id2'): return self._m_has_field_id2 self._m_has_field_id2 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_id2', None) @property def has_field_polygon_data(self): if hasattr(self, '_m_has_field_polygon_data'): return self._m_has_field_polygon_data self._m_has_field_polygon_data = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_polygon_data', None) class ConfigGuideShowPage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_context_name: self.context_name = AuxTypes.String(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() @property def has_field_context_name(self): if hasattr(self, '_m_has_field_context_name'): return self._m_has_field_context_name self._m_has_field_context_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_context_name', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) class ArrayOfConfigAudioStageProgressEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAudioStageProgressEvent(self._io, self, self._root)) class ArrayOfChessCardEffectLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ChessCardEffect(self._io, self, self._root)) class StateExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_state_name: self.state_name = AuxTypes.String(self._io, self, self._root) if self.has_field_state_type: self.state_type = Output.EnumStateType(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_state_name(self): if hasattr(self, '_m_has_field_state_name'): return self._m_has_field_state_name self._m_has_field_state_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_state_name', None) @property def has_field_state_type(self): if hasattr(self, '_m_has_field_state_type'): return self._m_has_field_state_type self._m_has_field_state_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_state_type', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rank', None) class IrodoriMasterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_id: self.level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_type: self.level_type = Output.EnumIrodoriMasterLevelType(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_sliver_challenge_id: self.sliver_challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gold_challenge_id: self.gold_challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gold_challenge_time: self.gold_challenge_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_cond_id: self.guide_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_desc: self.battle_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_battle_name: self.battle_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_battle_name(self): if hasattr(self, '_m_has_field_battle_name'): return self._m_has_field_battle_name self._m_has_field_battle_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_battle_name', None) @property def has_field_gold_challenge_time(self): if hasattr(self, '_m_has_field_gold_challenge_time'): return self._m_has_field_gold_challenge_time self._m_has_field_gold_challenge_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_gold_challenge_time', None) @property def has_field_level_type(self): if hasattr(self, '_m_has_field_level_type'): return self._m_has_field_level_type self._m_has_field_level_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level_type', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_guide_cond_id(self): if hasattr(self, '_m_has_field_guide_cond_id'): return self._m_has_field_guide_cond_id self._m_has_field_guide_cond_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_guide_cond_id', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_battle_desc(self): if hasattr(self, '_m_has_field_battle_desc'): return self._m_has_field_battle_desc self._m_has_field_battle_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_battle_desc', None) @property def has_field_level_id(self): if hasattr(self, '_m_has_field_level_id'): return self._m_has_field_level_id self._m_has_field_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_id', None) @property def has_field_sliver_challenge_id(self): if hasattr(self, '_m_has_field_sliver_challenge_id'): return self._m_has_field_sliver_challenge_id self._m_has_field_sliver_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_sliver_challenge_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_gold_challenge_id(self): if hasattr(self, '_m_has_field_gold_challenge_id'): return self._m_has_field_gold_challenge_id self._m_has_field_gold_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_gold_challenge_id', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_list', None) class ConfigMusicInt32noLessThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class SeaLampSectionMiniQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_section_id: self.section_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_special: self.is_special = self._io.read_u1() if self.has_field_mini_quest_id: self.mini_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_is_special(self): if hasattr(self, '_m_has_field_is_special'): return self._m_has_field_is_special self._m_has_field_is_special = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_is_special', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_section_id(self): if hasattr(self, '_m_has_field_section_id'): return self._m_has_field_section_id self._m_has_field_section_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_section_id', None) @property def has_field_mini_quest_id(self): if hasattr(self, '_m_has_field_mini_quest_id'): return self._m_has_field_mini_quest_id self._m_has_field_mini_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_mini_quest_id', None) class ArrayOfConfigAiMixinSetIntLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAiMixinSetInt(self._io, self, self._root)) class ConfigAnimationRecurrentSpeech(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_start: self.start = Output.ConfigFluctuatedValue(self._io, self, self._root) if self.has_field_interval: self.interval = Output.ConfigFluctuatedValue(self._io, self, self._root) if self.has_field_event_name: self.event_name = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_start(self): if hasattr(self, '_m_has_field_start'): return self._m_has_field_start self._m_has_field_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start', None) @property def has_field_interval(self): if hasattr(self, '_m_has_field_interval'): return self._m_has_field_interval self._m_has_field_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_interval', None) @property def has_field_event_name(self): if hasattr(self, '_m_has_field_event_name'): return self._m_has_field_event_name self._m_has_field_event_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_event_name', None) class DictOfEnumElementTypeConfigResonanceCutScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumElementTypeConfigResonanceCutScene(self._io, self, self._root)) class ProductPlayDetailConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfCoopCondConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.CoopCondConfig(self._io, self, self._root)) class LunaRiteBattleBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEmoSyncInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_data_path: self.data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_phoneme_path: self.phoneme_path = AuxTypes.String(self._io, self, self._root) if self.has_field_emotion_path: self.emotion_path = AuxTypes.String(self._io, self, self._root) if self.has_field_mate_data_path: self.mate_data_path = AuxTypes.String(self._io, self, self._root) if self.has_field_mate_phoneme_path: self.mate_phoneme_path = AuxTypes.String(self._io, self, self._root) if self.has_field_mate_emotion_path: self.mate_emotion_path = AuxTypes.String(self._io, self, self._root) if self.has_field_back_type: self.back_type = Output.EnumEmoBackType(self._io, self, self._root) if self.has_field_enable_blink: self.enable_blink = self._io.read_u1() if self.has_field_data_path_hash_list: self.data_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_phoneme_path_hash_list: self.phoneme_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_emotion_path_hash_list: self.emotion_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mate_data_path_hash_list: self.mate_data_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mate_phoneme_path_hash_list: self.mate_phoneme_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_mate_emotion_path_hash_list: self.mate_emotion_path_hash_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_emotion_path_hash_list(self): if hasattr(self, '_m_has_field_emotion_path_hash_list'): return self._m_has_field_emotion_path_hash_list self._m_has_field_emotion_path_hash_list = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_emotion_path_hash_list', None) @property def has_field_mate_emotion_path(self): if hasattr(self, '_m_has_field_mate_emotion_path'): return self._m_has_field_mate_emotion_path self._m_has_field_mate_emotion_path = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_mate_emotion_path', None) @property def has_field_phoneme_path(self): if hasattr(self, '_m_has_field_phoneme_path'): return self._m_has_field_phoneme_path self._m_has_field_phoneme_path = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_phoneme_path', None) @property def has_field_mate_data_path_hash_list(self): if hasattr(self, '_m_has_field_mate_data_path_hash_list'): return self._m_has_field_mate_data_path_hash_list self._m_has_field_mate_data_path_hash_list = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_mate_data_path_hash_list', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def has_field_mate_emotion_path_hash_list(self): if hasattr(self, '_m_has_field_mate_emotion_path_hash_list'): return self._m_has_field_mate_emotion_path_hash_list self._m_has_field_mate_emotion_path_hash_list = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_mate_emotion_path_hash_list', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_back_type(self): if hasattr(self, '_m_has_field_back_type'): return self._m_has_field_back_type self._m_has_field_back_type = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_back_type', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_mate_data_path(self): if hasattr(self, '_m_has_field_mate_data_path'): return self._m_has_field_mate_data_path self._m_has_field_mate_data_path = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_mate_data_path', None) @property def has_field_enable_blink(self): if hasattr(self, '_m_has_field_enable_blink'): return self._m_has_field_enable_blink self._m_has_field_enable_blink = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enable_blink', None) @property def has_field_mate_phoneme_path(self): if hasattr(self, '_m_has_field_mate_phoneme_path'): return self._m_has_field_mate_phoneme_path self._m_has_field_mate_phoneme_path = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_mate_phoneme_path', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_phoneme_path_hash_list(self): if hasattr(self, '_m_has_field_phoneme_path_hash_list'): return self._m_has_field_phoneme_path_hash_list self._m_has_field_phoneme_path_hash_list = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_phoneme_path_hash_list', None) @property def has_field_data_path_hash_list(self): if hasattr(self, '_m_has_field_data_path_hash_list'): return self._m_has_field_data_path_hash_list self._m_has_field_data_path_hash_list = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_data_path_hash_list', None) @property def has_field_emotion_path(self): if hasattr(self, '_m_has_field_emotion_path'): return self._m_has_field_emotion_path self._m_has_field_emotion_path = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_emotion_path', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_data_path(self): if hasattr(self, '_m_has_field_data_path'): return self._m_has_field_data_path self._m_has_field_data_path = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_data_path', None) @property def has_field_mate_phoneme_path_hash_list(self): if hasattr(self, '_m_has_field_mate_phoneme_path_hash_list'): return self._m_has_field_mate_phoneme_path_hash_list self._m_has_field_mate_phoneme_path_hash_list = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_mate_phoneme_path_hash_list', None) class ConfigHomeCommonPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rotation', None) class ArrayOfBlossomRewardExcelConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.BlossomRewardExcelConfig(self._io, self, self._root)) class BounceConjuringPreviewExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigNavigation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumNavType(self._io, self, self._root) if self.has_field_size_x: self.size_x = self._io.read_f4le() if self.has_field_size_y: self.size_y = self._io.read_f4le() if self.has_field_size_z: self.size_z = self._io.read_f4le() @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_size_x(self): if hasattr(self, '_m_has_field_size_x'): return self._m_has_field_size_x self._m_has_field_size_x = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_size_x', None) @property def has_field_size_y(self): if hasattr(self, '_m_has_field_size_y'): return self._m_has_field_size_y self._m_has_field_size_y = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_size_y', None) @property def has_field_size_z(self): if hasattr(self, '_m_has_field_size_z'): return self._m_has_field_size_z self._m_has_field_size_z = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_size_z', None) class IrodoriExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sub_id: self.sub_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_cond_id: self.open_cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_title: self.guide_quest_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_desc: self.guide_quest_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_guide_quest_title(self): if hasattr(self, '_m_has_field_guide_quest_title'): return self._m_has_field_guide_quest_title self._m_has_field_guide_quest_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_guide_quest_title', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_guide_quest_desc(self): if hasattr(self, '_m_has_field_guide_quest_desc'): return self._m_has_field_guide_quest_desc self._m_has_field_guide_quest_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_guide_quest_desc', None) @property def has_field_open_cond_id(self): if hasattr(self, '_m_has_field_open_cond_id'): return self._m_has_field_open_cond_id self._m_has_field_open_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_cond_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_sub_id(self): if hasattr(self, '_m_has_field_sub_id'): return self._m_has_field_sub_id self._m_has_field_sub_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sub_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) class EnableCrashDamage(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigGuideMechanicusPickCardCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_select: self.is_select = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_is_select(self): if hasattr(self, '_m_has_field_is_select'): return self._m_has_field_is_select self._m_has_field_is_select = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_select', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ArrayOfConfigCodexQuestTextLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCodexQuestText(self._io, self, self._root)) class ConfigAiFindBackSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiFindBackData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiFindBackData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class EnumVisionLevelType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VisionLevelType, self.data.value) return getattr(self, '_m_value', None) class TeamTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigEntity(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigTransPointEntity(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigMonster(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigNpc(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigGadget(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigLevelEntity(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigAvatar(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCharacter(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class EnumRelationalOperator(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RelationalOperator, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringDispConfigBaseStateIdInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.DispConfigBaseStateIdInfo(self._io, self, self._root) class DungunEntryTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigShopExchangeInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_shop_type: self.shop_type = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_shop_type', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class DictOfEnumKeyboardTypeConfigKeyboardLayoutItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumKeyboardTypeConfigKeyboardLayoutItem(self._io, self, self._root)) class ConfigMusicUIntAbsenceStimulusHandler(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUIntMultiValueStimulusHandler(self._io, self, self._root) @property def uint_params(self): if hasattr(self, '_m_uint_params'): return self._m_uint_params self._m_uint_params = self.base.uint_params return getattr(self, '_m_uint_params', None) @property def stimulus(self): if hasattr(self, '_m_stimulus'): return self._m_stimulus self._m_stimulus = self.base.stimulus return getattr(self, '_m_stimulus', None) @property def transitions(self): if hasattr(self, '_m_transitions'): return self._m_transitions self._m_transitions = self.base.transitions return getattr(self, '_m_transitions', None) class ConfigControlPartByIkccd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigControlPartByIk(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_root_name: self.root_name = AuxTypes.String(self._io, self, self._root) if self.has_field_final_axial_fix: self.final_axial_fix = Output.Vector(self._io, self, self._root) if self.has_field_vertical_damping: self.vertical_damping = self._io.read_f4le() @property def forward_by_trans_name(self): if hasattr(self, '_m_forward_by_trans_name'): return self._m_forward_by_trans_name self._m_forward_by_trans_name = self.base.forward_by_trans_name return getattr(self, '_m_forward_by_trans_name', None) @property def forward_by(self): if hasattr(self, '_m_forward_by'): return self._m_forward_by self._m_forward_by = self.base.forward_by return getattr(self, '_m_forward_by', None) @property def has_field_final_axial_fix(self): if hasattr(self, '_m_has_field_final_axial_fix'): return self._m_has_field_final_axial_fix self._m_has_field_final_axial_fix = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_final_axial_fix', None) @property def rotate_by(self): if hasattr(self, '_m_rotate_by'): return self._m_rotate_by self._m_rotate_by = self.base.rotate_by return getattr(self, '_m_rotate_by', None) @property def forward_axial_fix(self): if hasattr(self, '_m_forward_axial_fix'): return self._m_forward_axial_fix self._m_forward_axial_fix = self.base.forward_axial_fix return getattr(self, '_m_forward_axial_fix', None) @property def do_on_un_eabled(self): if hasattr(self, '_m_do_on_un_eabled'): return self._m_do_on_un_eabled self._m_do_on_un_eabled = self.base.do_on_un_eabled return getattr(self, '_m_do_on_un_eabled', None) @property def has_field_vertical_damping(self): if hasattr(self, '_m_has_field_vertical_damping'): return self._m_has_field_vertical_damping self._m_has_field_vertical_damping = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_vertical_damping', None) @property def limit_vertical(self): if hasattr(self, '_m_limit_vertical'): return self._m_limit_vertical self._m_limit_vertical = self.base.limit_vertical return getattr(self, '_m_limit_vertical', None) @property def limit_horizontal(self): if hasattr(self, '_m_limit_horizontal'): return self._m_limit_horizontal self._m_limit_horizontal = self.base.limit_horizontal return getattr(self, '_m_limit_horizontal', None) @property def part_root_name(self): if hasattr(self, '_m_part_root_name'): return self._m_part_root_name self._m_part_root_name = self.base.part_root_name return getattr(self, '_m_part_root_name', None) @property def angular_speed(self): if hasattr(self, '_m_angular_speed'): return self._m_angular_speed self._m_angular_speed = self.base.angular_speed return getattr(self, '_m_angular_speed', None) @property def has_field_root_name(self): if hasattr(self, '_m_has_field_root_name'): return self._m_has_field_root_name self._m_has_field_root_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_root_name', None) @property def target_type(self): if hasattr(self, '_m_target_type'): return self._m_target_type self._m_target_type = self.base.target_type return getattr(self, '_m_target_type', None) class ConfigMusicSingleCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicParameterCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class AbilityEntityVisibleReasonComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityDoSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_hold: self.is_hold = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_hold(self): if hasattr(self, '_m_has_field_is_hold'): return self._m_has_field_is_hold self._m_has_field_is_hold = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_hold', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumActionPanelState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionPanelState, self.data.value) return getattr(self, '_m_value', None) class DoubleNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) class DictOfAuxTypesStringConfigBaseContext(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigBaseContext(self._io, self, self._root)) class ConfigElementUi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_show_icon_entity_types: self.show_icon_entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_show_reaction_entity_types: self.show_reaction_entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_icon_recover_time: self.icon_recover_time = self._io.read_f4le() if self.has_field_icon_disappear_time: self.icon_disappear_time = self._io.read_f4le() if self.has_field_icon_disappear_round: self.icon_disappear_round = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_show_distance: self.icon_show_distance = self._io.read_f4le() if self.has_field_override_elem_path: self.override_elem_path = Output.DictOfAuxTypesStringAuxTypesString(self._io, self, self._root) if self.has_field_reaction_elem_path: self.reaction_elem_path = Output.DictOfEnumElementReactionTypeAuxTypesString(self._io, self, self._root) @property def has_field_icon_show_distance(self): if hasattr(self, '_m_has_field_icon_show_distance'): return self._m_has_field_icon_show_distance self._m_has_field_icon_show_distance = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_icon_show_distance', None) @property def has_field_override_elem_path(self): if hasattr(self, '_m_has_field_override_elem_path'): return self._m_has_field_override_elem_path self._m_has_field_override_elem_path = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_override_elem_path', None) @property def has_field_reaction_elem_path(self): if hasattr(self, '_m_has_field_reaction_elem_path'): return self._m_has_field_reaction_elem_path self._m_has_field_reaction_elem_path = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_reaction_elem_path', None) @property def has_field_icon_recover_time(self): if hasattr(self, '_m_has_field_icon_recover_time'): return self._m_has_field_icon_recover_time self._m_has_field_icon_recover_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_icon_recover_time', None) @property def has_field_icon_disappear_round(self): if hasattr(self, '_m_has_field_icon_disappear_round'): return self._m_has_field_icon_disappear_round self._m_has_field_icon_disappear_round = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_icon_disappear_round', None) @property def has_field_show_icon_entity_types(self): if hasattr(self, '_m_has_field_show_icon_entity_types'): return self._m_has_field_show_icon_entity_types self._m_has_field_show_icon_entity_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show_icon_entity_types', None) @property def has_field_icon_disappear_time(self): if hasattr(self, '_m_has_field_icon_disappear_time'): return self._m_has_field_icon_disappear_time self._m_has_field_icon_disappear_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_icon_disappear_time', None) @property def has_field_show_reaction_entity_types(self): if hasattr(self, '_m_has_field_show_reaction_entity_types'): return self._m_has_field_show_reaction_entity_types self._m_has_field_show_reaction_entity_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_show_reaction_entity_types', None) class ConfigBornByFollowEffectOverPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_by_owner: self.by_owner = self._io.read_u1() @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def has_field_by_owner(self): if hasattr(self, '_m_has_field_by_owner'): return self._m_has_field_by_owner self._m_has_field_by_owner = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_by_owner', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class IndicatorConditionDummyPointDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = Output.TemplateParamString(self._io, self, self._root) if self.has_field_distance: self.distance = Output.TemplateParamFloat(self._io, self, self._root) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_distance', None) class ConfigRiseField(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigForceField(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cdmin: self.cdmin = self._io.read_f4le() if self.has_field_cdmax: self.cdmax = self._io.read_f4le() if self.has_field_vmin: self.vmin = self._io.read_f4le() if self.has_field_vmax: self.vmax = self._io.read_f4le() if self.has_field_hmin: self.hmin = self._io.read_f4le() if self.has_field_hmax: self.hmax = self._io.read_f4le() if self.has_field_attenuation: self.attenuation = self._io.read_f4le() if self.has_field_box: self.box = Output.Vector(self._io, self, self._root) if self.has_field_shape: self.shape = Output.DispConfigBaseShape(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def has_field_shape(self): if hasattr(self, '_m_has_field_shape'): return self._m_has_field_shape self._m_has_field_shape = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_shape', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def has_field_vmax(self): if hasattr(self, '_m_has_field_vmax'): return self._m_has_field_vmax self._m_has_field_vmax = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_vmax', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def has_field_attenuation(self): if hasattr(self, '_m_has_field_attenuation'): return self._m_has_field_attenuation self._m_has_field_attenuation = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_attenuation', None) @property def has_field_vmin(self): if hasattr(self, '_m_has_field_vmin'): return self._m_has_field_vmin self._m_has_field_vmin = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_vmin', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_hmax(self): if hasattr(self, '_m_has_field_hmax'): return self._m_has_field_hmax self._m_has_field_hmax = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_hmax', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def has_field_cdmin(self): if hasattr(self, '_m_has_field_cdmin'): return self._m_has_field_cdmin self._m_has_field_cdmin = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_cdmin', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_box(self): if hasattr(self, '_m_has_field_box'): return self._m_has_field_box self._m_has_field_box = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_box', None) @property def has_field_cdmax(self): if hasattr(self, '_m_has_field_cdmax'): return self._m_has_field_cdmax self._m_has_field_cdmax = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_cdmax', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_hmin(self): if hasattr(self, '_m_has_field_hmin'): return self._m_has_field_hmin self._m_has_field_hmin = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_hmin', None) class EnumUgcTimeControlType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UgcTimeControlType, self.data.value) return getattr(self, '_m_value', None) class ContextActionSetText(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_element: self.ui_element = Output.EnumActivityBannerUiElementType(self._io, self, self._root) if self.has_field_text_map: self.text_map = AuxTypes.String(self._io, self, self._root) @property def has_field_ui_element(self): if hasattr(self, '_m_has_field_ui_element'): return self._m_has_field_ui_element self._m_has_field_ui_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_element', None) @property def has_field_text_map(self): if hasattr(self, '_m_has_field_text_map'): return self._m_has_field_text_map self._m_has_field_text_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_text_map', None) class EnumAiBasicMoveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AiBasicMoveType, self.data.value) return getattr(self, '_m_value', None) class EnumGadgetType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetType, self.data.value) return getattr(self, '_m_value', None) class EnableManualOcclusionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class RogueStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_first_pass_reward_id: self.first_pass_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward_id: self.preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_time: self.open_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_coin: self.max_coin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_level: self.max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_revise_level_id: self.revise_level_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_name: self.stage_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_desc: self.stage_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_boss_id_list: self.boss_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_monster_id_list: self.monster_id_list = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) if self.has_field_level_boss_id_list: self.level_boss_id_list = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_goto_quest_id: self.goto_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_rune_list: self.unlock_rune_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_story_stage: self.is_story_stage = self._io.read_u1() @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_is_story_stage(self): if hasattr(self, '_m_has_field_is_story_stage'): return self._m_has_field_is_story_stage self._m_has_field_is_story_stage = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_story_stage', None) @property def has_field_first_pass_reward_id(self): if hasattr(self, '_m_has_field_first_pass_reward_id'): return self._m_has_field_first_pass_reward_id self._m_has_field_first_pass_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_first_pass_reward_id', None) @property def has_field_revise_level_id(self): if hasattr(self, '_m_has_field_revise_level_id'): return self._m_has_field_revise_level_id self._m_has_field_revise_level_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_revise_level_id', None) @property def has_field_stage_desc(self): if hasattr(self, '_m_has_field_stage_desc'): return self._m_has_field_stage_desc self._m_has_field_stage_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_stage_desc', None) @property def has_field_open_time(self): if hasattr(self, '_m_has_field_open_time'): return self._m_has_field_open_time self._m_has_field_open_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_open_time', None) @property def has_field_unlock_rune_list(self): if hasattr(self, '_m_has_field_unlock_rune_list'): return self._m_has_field_unlock_rune_list self._m_has_field_unlock_rune_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_unlock_rune_list', None) @property def has_field_max_level(self): if hasattr(self, '_m_has_field_max_level'): return self._m_has_field_max_level self._m_has_field_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_max_level', None) @property def has_field_max_coin(self): if hasattr(self, '_m_has_field_max_coin'): return self._m_has_field_max_coin self._m_has_field_max_coin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_max_coin', None) @property def has_field_level_boss_id_list(self): if hasattr(self, '_m_has_field_level_boss_id_list'): return self._m_has_field_level_boss_id_list self._m_has_field_level_boss_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_level_boss_id_list', None) @property def has_field_monster_id_list(self): if hasattr(self, '_m_has_field_monster_id_list'): return self._m_has_field_monster_id_list self._m_has_field_monster_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_monster_id_list', None) @property def has_field_goto_quest_id(self): if hasattr(self, '_m_has_field_goto_quest_id'): return self._m_has_field_goto_quest_id self._m_has_field_goto_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_goto_quest_id', None) @property def has_field_stage_name(self): if hasattr(self, '_m_has_field_stage_name'): return self._m_has_field_stage_name self._m_has_field_stage_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_stage_name', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) @property def has_field_boss_id_list(self): if hasattr(self, '_m_has_field_boss_id_list'): return self._m_has_field_boss_id_list self._m_has_field_boss_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_boss_id_list', None) @property def has_field_preview_reward_id(self): if hasattr(self, '_m_has_field_preview_reward_id'): return self._m_has_field_preview_reward_id self._m_has_field_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_preview_reward_id', None) class ArrayOfConfigRecordEmoFuncLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRecordEmoFunc(self._io, self, self._root)) class LuminanceStoneChallengeStageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_day_index: self.day_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_title: self.stage_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_desc: self.stage_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_lock_title: self.stage_lock_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_lock_desc: self.stage_lock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_related_cond_id: self.related_cond_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_list: self.watcher_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_quest_list: self.quest_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bundle_id: self.bundle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_stage_lock_title(self): if hasattr(self, '_m_has_field_stage_lock_title'): return self._m_has_field_stage_lock_title self._m_has_field_stage_lock_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_stage_lock_title', None) @property def has_field_related_cond_id(self): if hasattr(self, '_m_has_field_related_cond_id'): return self._m_has_field_related_cond_id self._m_has_field_related_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_related_cond_id', None) @property def has_field_quest_list(self): if hasattr(self, '_m_has_field_quest_list'): return self._m_has_field_quest_list self._m_has_field_quest_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_quest_list', None) @property def has_field_stage_desc(self): if hasattr(self, '_m_has_field_stage_desc'): return self._m_has_field_stage_desc self._m_has_field_stage_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_stage_desc', None) @property def has_field_stage_lock_desc(self): if hasattr(self, '_m_has_field_stage_lock_desc'): return self._m_has_field_stage_lock_desc self._m_has_field_stage_lock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_stage_lock_desc', None) @property def has_field_bundle_id(self): if hasattr(self, '_m_has_field_bundle_id'): return self._m_has_field_bundle_id self._m_has_field_bundle_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_bundle_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_stage_title(self): if hasattr(self, '_m_has_field_stage_title'): return self._m_has_field_stage_title self._m_has_field_stage_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_stage_title', None) @property def has_field_day_index(self): if hasattr(self, '_m_has_field_day_index'): return self._m_has_field_day_index self._m_has_field_day_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_day_index', None) @property def has_field_watcher_list(self): if hasattr(self, '_m_has_field_watcher_list'): return self._m_has_field_watcher_list self._m_has_field_watcher_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_watcher_list', None) class ArrayOfRendererFloatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RendererFloat(self._io, self, self._root)) class EnumCardFortuneType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CardFortuneType, self.data.value) return getattr(self, '_m_value', None) class OverflowTransformExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByCurTeamHasWeaponType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weapon_type: self.weapon_type = AuxTypes.String(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_weapon_type(self): if hasattr(self, '_m_has_field_weapon_type'): return self._m_has_field_weapon_type self._m_has_field_weapon_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weapon_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class AvatarSpeechEquipObtain(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_event_name: self.event_name = Output.ConfigWwiseString(self._io, self, self._root) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_quality', None) @property def has_field_event_name(self): if hasattr(self, '_m_has_field_event_name'): return self._m_has_field_event_name self._m_has_field_event_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_name', None) class ConfigAbilityData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_color_tag: self.color_tag = AuxTypes.String(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_msg: self.msg = AuxTypes.String(self._io, self, self._root) if self.has_field_can_preview: self.can_preview = self._io.read_u1() @property def has_field_color_tag(self): if hasattr(self, '_m_has_field_color_tag'): return self._m_has_field_color_tag self._m_has_field_color_tag = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_color_tag', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_msg(self): if hasattr(self, '_m_has_field_msg'): return self._m_has_field_msg self._m_has_field_msg = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_msg', None) @property def has_field_can_preview(self): if hasattr(self, '_m_has_field_can_preview'): return self._m_has_field_can_preview self._m_has_field_can_preview = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_can_preview', None) class ConfigAitsAbilityGlobalValueSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiThreatScoreBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_cared_global_value_name: self.cared_global_value_name = AuxTypes.String(self._io, self, self._root) @property def max(self): if hasattr(self, '_m_max'): return self._m_max self._m_max = self.base.max return getattr(self, '_m_max', None) @property def min(self): if hasattr(self, '_m_min'): return self._m_min self._m_min = self.base.min return getattr(self, '_m_min', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def compare_operation(self): if hasattr(self, '_m_compare_operation'): return self._m_compare_operation self._m_compare_operation = self.base.compare_operation return getattr(self, '_m_compare_operation', None) @property def has_field_cared_global_value_name(self): if hasattr(self, '_m_has_field_cared_global_value_name'): return self._m_has_field_cared_global_value_name self._m_has_field_cared_global_value_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_cared_global_value_name', None) @property def weight(self): if hasattr(self, '_m_weight'): return self._m_weight self._m_weight = self.base.weight return getattr(self, '_m_weight', None) class FleurFairMiniGameExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mini_game_type: self.mini_game_type = Output.EnumFleurFairMiniGameType(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_rank_low: self.reward_rank_low = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_rank_middle: self.reward_rank_middle = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_rank_high: self.reward_rank_high = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_id_list: self.avatar_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_score: self.avatar_score = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tips_id_list: self.tips_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tips_desc: self.tips_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pos: self.pos = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_mini_game_type(self): if hasattr(self, '_m_has_field_mini_game_type'): return self._m_has_field_mini_game_type self._m_has_field_mini_game_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mini_game_type', None) @property def has_field_tips_desc(self): if hasattr(self, '_m_has_field_tips_desc'): return self._m_has_field_tips_desc self._m_has_field_tips_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_tips_desc', None) @property def has_field_reward_rank_middle(self): if hasattr(self, '_m_has_field_reward_rank_middle'): return self._m_has_field_reward_rank_middle self._m_has_field_reward_rank_middle = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_reward_rank_middle', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_reward_rank_high(self): if hasattr(self, '_m_has_field_reward_rank_high'): return self._m_has_field_reward_rank_high self._m_has_field_reward_rank_high = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_reward_rank_high', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_pos(self): if hasattr(self, '_m_has_field_pos'): return self._m_has_field_pos self._m_has_field_pos = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_pos', None) @property def has_field_tips_id_list(self): if hasattr(self, '_m_has_field_tips_id_list'): return self._m_has_field_tips_id_list self._m_has_field_tips_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_tips_id_list', None) @property def has_field_reward_rank_low(self): if hasattr(self, '_m_has_field_reward_rank_low'): return self._m_has_field_reward_rank_low self._m_has_field_reward_rank_low = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_reward_rank_low', None) @property def has_field_avatar_score(self): if hasattr(self, '_m_has_field_avatar_score'): return self._m_has_field_avatar_score self._m_has_field_avatar_score = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_avatar_score', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_avatar_id_list(self): if hasattr(self, '_m_has_field_avatar_id_list'): return self._m_has_field_avatar_id_list self._m_has_field_avatar_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_avatar_id_list', None) class HuntingMonsterCreatePosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityCrystalLinkEffectBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumSpeicalFurnitureType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SpeicalFurnitureType, self.data.value) return getattr(self, '_m_value', None) class SetGlobalPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_set_target: self.set_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_target(self): if hasattr(self, '_m_has_field_set_target'): return self._m_has_field_set_target self._m_has_field_set_target = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_set_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class ConfigMusicDoubleInequalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicDoubleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class KvpOfDictEnumAnimeGroupTypeConfigAnimGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumAnimeGroupType(self._io, self, self._root) self.value = Output.ConfigAnimGroup(self._io, self, self._root) class KvpOfDictAuxTypesStringArrayOfEnumVoiceLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfEnumVoiceLanguageTypeLengthU(self._io, self, self._root) class AddChargeBarValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_random_in_range: self.random_in_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_value', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_random_in_range(self): if hasattr(self, '_m_has_field_random_in_range'): return self._m_has_field_random_in_range self._m_has_field_random_in_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_random_in_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class HuntingClueGatherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicDisjunctiveCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicBinaryCondition(self._io, self, self._root) @property def lhs_id(self): if hasattr(self, '_m_lhs_id'): return self._m_lhs_id self._m_lhs_id = self.base.lhs_id return getattr(self, '_m_lhs_id', None) @property def rhs_id(self): if hasattr(self, '_m_rhs_id'): return self._m_rhs_id self._m_rhs_id = self.base.rhs_id return getattr(self, '_m_rhs_id', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class MonsterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_monster_name: self.monster_name = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumMonsterType(self._io, self, self._root) if self.has_field_security_level: self.security_level = Output.EnumMonsterSecurityLevel(self._io, self, self._root) if self.has_field_script_data_path_hash: self.script_data_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_script: self.server_script = AuxTypes.String(self._io, self, self._root) if self.has_field_combat_config_hash: self.combat_config_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_affix: self.affix = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_ai: self.ai = AuxTypes.String(self._io, self, self._root) if self.has_field_is_ai_hash_check: self.is_ai_hash_check = self._io.read_u1() if self.has_field_equips: self.equips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_can_swim: self.can_swim = self._io.read_u1() if self.has_field_hp_drops: self.hp_drops = Output.ArrayOfMonsterDropLengthS(self._io, self, self._root) if self.has_field_kill_drop_id: self.kill_drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_scene_reward: self.is_scene_reward = self._io.read_u1() if self.has_field_vision_level: self.vision_level = Output.EnumVisionLevelType(self._io, self, self._root) if self.has_field_is_invisible_reset: self.is_invisible_reset = self._io.read_u1() if self.has_field_exclude_weathers: self.exclude_weathers = AuxTypes.String(self._io, self, self._root) if self.has_field_feature_tag_group_id: self.feature_tag_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mp_prop_id: self.mp_prop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skin: self.skin = AuxTypes.String(self._io, self, self._root) if self.has_field_describe_id: self.describe_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_safety_check: self.safety_check = self._io.read_u1() if self.has_field_combat_bgm_level: self.combat_bgm_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_entity_budget_level: self.entity_budget_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_radar_hint_id: self.radar_hint_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sus4: self.sus4 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hp_base: self.hp_base = self._io.read_f4le() if self.has_field_attack_base: self.attack_base = self._io.read_f4le() if self.has_field_defense_base: self.defense_base = self._io.read_f4le() if self.has_field_critical: self.critical = self._io.read_f4le() if self.has_field_anti_critical: self.anti_critical = self._io.read_f4le() if self.has_field_critical_hurt: self.critical_hurt = self._io.read_f4le() if self.has_field_fire_sub_hurt: self.fire_sub_hurt = self._io.read_f4le() if self.has_field_grass_sub_hurt: self.grass_sub_hurt = self._io.read_f4le() if self.has_field_water_sub_hurt: self.water_sub_hurt = self._io.read_f4le() if self.has_field_elec_sub_hurt: self.elec_sub_hurt = self._io.read_f4le() if self.has_field_wind_sub_hurt: self.wind_sub_hurt = self._io.read_f4le() if self.has_field_ice_sub_hurt: self.ice_sub_hurt = self._io.read_f4le() if self.has_field_rock_sub_hurt: self.rock_sub_hurt = self._io.read_f4le() if self.has_field_fire_add_hurt: self.fire_add_hurt = self._io.read_f4le() if self.has_field_grass_add_hurt: self.grass_add_hurt = self._io.read_f4le() if self.has_field_water_add_hurt: self.water_add_hurt = self._io.read_f4le() if self.has_field_elec_add_hurt: self.elec_add_hurt = self._io.read_f4le() if self.has_field_wind_add_hurt: self.wind_add_hurt = self._io.read_f4le() if self.has_field_ice_add_hurt: self.ice_add_hurt = self._io.read_f4le() if self.has_field_rock_add_hurt: self.rock_add_hurt = self._io.read_f4le() if self.has_field_prop_grow_curves: self.prop_grow_curves = Output.ArrayOfFightPropGrowConfigLengthS(self._io, self, self._root) if self.has_field_element_mastery: self.element_mastery = self._io.read_f4le() if self.has_field_physical_sub_hurt: self.physical_sub_hurt = self._io.read_f4le() if self.has_field_physical_add_hurt: self.physical_add_hurt = self._io.read_f4le() if self.has_field_prefab_path_ragdoll_hash: self.prefab_path_ragdoll_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sus5: self.sus5 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_hash: self.prefab_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_prefab_path_remote_hash: self.prefab_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_hash: self.controller_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_controller_path_remote_hash: self.controller_path_remote_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_id: self.camp_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lod_pattern_name: self.lod_pattern_name = AuxTypes.String(self._io, self, self._root) @property def has_field_kill_drop_id(self): if hasattr(self, '_m_has_field_kill_drop_id'): return self._m_has_field_kill_drop_id self._m_has_field_kill_drop_id = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_kill_drop_id', None) @property def has_field_radar_hint_id(self): if hasattr(self, '_m_has_field_radar_hint_id'): return self._m_has_field_radar_hint_id self._m_has_field_radar_hint_id = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_radar_hint_id', None) @property def has_field_critical(self): if hasattr(self, '_m_has_field_critical'): return self._m_has_field_critical self._m_has_field_critical = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 128) != 0)) return getattr(self, '_m_has_field_critical', None) @property def has_field_rock_add_hurt(self): if hasattr(self, '_m_has_field_rock_add_hurt'): return self._m_has_field_rock_add_hurt self._m_has_field_rock_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 128) != 0)) return getattr(self, '_m_has_field_rock_add_hurt', None) @property def has_field_camp_id(self): if hasattr(self, '_m_has_field_camp_id'): return self._m_has_field_camp_id self._m_has_field_camp_id = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 16) != 0)) return getattr(self, '_m_has_field_camp_id', None) @property def has_field_equips(self): if hasattr(self, '_m_has_field_equips'): return self._m_has_field_equips self._m_has_field_equips = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_equips', None) @property def has_field_exclude_weathers(self): if hasattr(self, '_m_has_field_exclude_weathers'): return self._m_has_field_exclude_weathers self._m_has_field_exclude_weathers = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_exclude_weathers', None) @property def has_field_fire_sub_hurt(self): if hasattr(self, '_m_has_field_fire_sub_hurt'): return self._m_has_field_fire_sub_hurt self._m_has_field_fire_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 4) != 0)) return getattr(self, '_m_has_field_fire_sub_hurt', None) @property def has_field_physical_sub_hurt(self): if hasattr(self, '_m_has_field_physical_sub_hurt'): return self._m_has_field_physical_sub_hurt self._m_has_field_physical_sub_hurt = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 4) != 0)) return getattr(self, '_m_has_field_physical_sub_hurt', None) @property def has_field_security_level(self): if hasattr(self, '_m_has_field_security_level'): return self._m_has_field_security_level self._m_has_field_security_level = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_security_level', None) @property def has_field_attack_base(self): if hasattr(self, '_m_has_field_attack_base'): return self._m_has_field_attack_base self._m_has_field_attack_base = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 32) != 0)) return getattr(self, '_m_has_field_attack_base', None) @property def has_field_prefab_path_hash(self): if hasattr(self, '_m_has_field_prefab_path_hash'): return self._m_has_field_prefab_path_hash self._m_has_field_prefab_path_hash = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 1) != 0)) return getattr(self, '_m_has_field_prefab_path_hash', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 128) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_hp_base(self): if hasattr(self, '_m_has_field_hp_base'): return self._m_has_field_hp_base self._m_has_field_hp_base = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_hp_base', None) @property def has_field_sus(self): if hasattr(self, '_m_has_field_sus'): return self._m_has_field_sus self._m_has_field_sus = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sus', None) @property def has_field_mp_prop_id(self): if hasattr(self, '_m_has_field_mp_prop_id'): return self._m_has_field_mp_prop_id self._m_has_field_mp_prop_id = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_mp_prop_id', None) @property def has_field_ice_sub_hurt(self): if hasattr(self, '_m_has_field_ice_sub_hurt'): return self._m_has_field_ice_sub_hurt self._m_has_field_ice_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 128) != 0)) return getattr(self, '_m_has_field_ice_sub_hurt', None) @property def has_field_hp_drops(self): if hasattr(self, '_m_has_field_hp_drops'): return self._m_has_field_hp_drops self._m_has_field_hp_drops = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_hp_drops', None) @property def has_field_ice_add_hurt(self): if hasattr(self, '_m_has_field_ice_add_hurt'): return self._m_has_field_ice_add_hurt self._m_has_field_ice_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 64) != 0)) return getattr(self, '_m_has_field_ice_add_hurt', None) @property def has_field_wind_sub_hurt(self): if hasattr(self, '_m_has_field_wind_sub_hurt'): return self._m_has_field_wind_sub_hurt self._m_has_field_wind_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 64) != 0)) return getattr(self, '_m_has_field_wind_sub_hurt', None) @property def has_field_elec_sub_hurt(self): if hasattr(self, '_m_has_field_elec_sub_hurt'): return self._m_has_field_elec_sub_hurt self._m_has_field_elec_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 32) != 0)) return getattr(self, '_m_has_field_elec_sub_hurt', None) @property def has_field_affix(self): if hasattr(self, '_m_has_field_affix'): return self._m_has_field_affix self._m_has_field_affix = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_affix', None) @property def has_field_combat_config_hash(self): if hasattr(self, '_m_has_field_combat_config_hash'): return self._m_has_field_combat_config_hash self._m_has_field_combat_config_hash = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_combat_config_hash', None) @property def has_field_fire_add_hurt(self): if hasattr(self, '_m_has_field_fire_add_hurt'): return self._m_has_field_fire_add_hurt self._m_has_field_fire_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 2) != 0)) return getattr(self, '_m_has_field_fire_add_hurt', None) @property def has_field_grass_sub_hurt(self): if hasattr(self, '_m_has_field_grass_sub_hurt'): return self._m_has_field_grass_sub_hurt self._m_has_field_grass_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 8) != 0)) return getattr(self, '_m_has_field_grass_sub_hurt', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_safety_check(self): if hasattr(self, '_m_has_field_safety_check'): return self._m_has_field_safety_check self._m_has_field_safety_check = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_safety_check', None) @property def has_field_script_data_path_hash(self): if hasattr(self, '_m_has_field_script_data_path_hash'): return self._m_has_field_script_data_path_hash self._m_has_field_script_data_path_hash = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_script_data_path_hash', None) @property def has_field_elec_add_hurt(self): if hasattr(self, '_m_has_field_elec_add_hurt'): return self._m_has_field_elec_add_hurt self._m_has_field_elec_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 16) != 0)) return getattr(self, '_m_has_field_elec_add_hurt', None) @property def has_field_is_invisible_reset(self): if hasattr(self, '_m_has_field_is_invisible_reset'): return self._m_has_field_is_invisible_reset self._m_has_field_is_invisible_reset = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_is_invisible_reset', None) @property def has_field_feature_tag_group_id(self): if hasattr(self, '_m_has_field_feature_tag_group_id'): return self._m_has_field_feature_tag_group_id self._m_has_field_feature_tag_group_id = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_feature_tag_group_id', None) @property def has_field_physical_add_hurt(self): if hasattr(self, '_m_has_field_physical_add_hurt'): return self._m_has_field_physical_add_hurt self._m_has_field_physical_add_hurt = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 8) != 0)) return getattr(self, '_m_has_field_physical_add_hurt', None) @property def has_field_entity_budget_level(self): if hasattr(self, '_m_has_field_entity_budget_level'): return self._m_has_field_entity_budget_level self._m_has_field_entity_budget_level = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_entity_budget_level', None) @property def has_field_can_swim(self): if hasattr(self, '_m_has_field_can_swim'): return self._m_has_field_can_swim self._m_has_field_can_swim = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_can_swim', None) @property def has_field_server_script(self): if hasattr(self, '_m_has_field_server_script'): return self._m_has_field_server_script self._m_has_field_server_script = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_server_script', None) @property def has_field_element_mastery(self): if hasattr(self, '_m_has_field_element_mastery'): return self._m_has_field_element_mastery self._m_has_field_element_mastery = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 2) != 0)) return getattr(self, '_m_has_field_element_mastery', None) @property def has_field_prefab_path_remote_hash(self): if hasattr(self, '_m_has_field_prefab_path_remote_hash'): return self._m_has_field_prefab_path_remote_hash self._m_has_field_prefab_path_remote_hash = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 2) != 0)) return getattr(self, '_m_has_field_prefab_path_remote_hash', None) @property def has_field_monster_name(self): if hasattr(self, '_m_has_field_monster_name'): return self._m_has_field_monster_name self._m_has_field_monster_name = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_name', None) @property def has_field_wind_add_hurt(self): if hasattr(self, '_m_has_field_wind_add_hurt'): return self._m_has_field_wind_add_hurt self._m_has_field_wind_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 32) != 0)) return getattr(self, '_m_has_field_wind_add_hurt', None) @property def has_field_skin(self): if hasattr(self, '_m_has_field_skin'): return self._m_has_field_skin self._m_has_field_skin = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_skin', None) @property def has_field_anti_critical(self): if hasattr(self, '_m_has_field_anti_critical'): return self._m_has_field_anti_critical self._m_has_field_anti_critical = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 1) != 0)) return getattr(self, '_m_has_field_anti_critical', None) @property def has_field_lod_pattern_name(self): if hasattr(self, '_m_has_field_lod_pattern_name'): return self._m_has_field_lod_pattern_name self._m_has_field_lod_pattern_name = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 32) != 0)) return getattr(self, '_m_has_field_lod_pattern_name', None) @property def has_field_water_sub_hurt(self): if hasattr(self, '_m_has_field_water_sub_hurt'): return self._m_has_field_water_sub_hurt self._m_has_field_water_sub_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 16) != 0)) return getattr(self, '_m_has_field_water_sub_hurt', None) @property def has_field_sus4(self): if hasattr(self, '_m_has_field_sus4'): return self._m_has_field_sus4 self._m_has_field_sus4 = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_sus4', None) @property def has_field_is_ai_hash_check(self): if hasattr(self, '_m_has_field_is_ai_hash_check'): return self._m_has_field_is_ai_hash_check self._m_has_field_is_ai_hash_check = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_ai_hash_check', None) @property def has_field_controller_path_remote_hash(self): if hasattr(self, '_m_has_field_controller_path_remote_hash'): return self._m_has_field_controller_path_remote_hash self._m_has_field_controller_path_remote_hash = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 8) != 0)) return getattr(self, '_m_has_field_controller_path_remote_hash', None) @property def has_field_defense_base(self): if hasattr(self, '_m_has_field_defense_base'): return self._m_has_field_defense_base self._m_has_field_defense_base = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 64) != 0)) return getattr(self, '_m_has_field_defense_base', None) @property def has_field_critical_hurt(self): if hasattr(self, '_m_has_field_critical_hurt'): return self._m_has_field_critical_hurt self._m_has_field_critical_hurt = ((self.bit_field.length.value >= 5) and ((self.bit_field.bitfield[4] & 2) != 0)) return getattr(self, '_m_has_field_critical_hurt', None) @property def has_field_ai(self): if hasattr(self, '_m_has_field_ai'): return self._m_has_field_ai self._m_has_field_ai = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_ai', None) @property def has_field_water_add_hurt(self): if hasattr(self, '_m_has_field_water_add_hurt'): return self._m_has_field_water_add_hurt self._m_has_field_water_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 8) != 0)) return getattr(self, '_m_has_field_water_add_hurt', None) @property def has_field_rock_sub_hurt(self): if hasattr(self, '_m_has_field_rock_sub_hurt'): return self._m_has_field_rock_sub_hurt self._m_has_field_rock_sub_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 1) != 0)) return getattr(self, '_m_has_field_rock_sub_hurt', None) @property def has_field_describe_id(self): if hasattr(self, '_m_has_field_describe_id'): return self._m_has_field_describe_id self._m_has_field_describe_id = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_describe_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 64) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_controller_path_hash(self): if hasattr(self, '_m_has_field_controller_path_hash'): return self._m_has_field_controller_path_hash self._m_has_field_controller_path_hash = ((self.bit_field.length.value >= 8) and ((self.bit_field.bitfield[7] & 4) != 0)) return getattr(self, '_m_has_field_controller_path_hash', None) @property def has_field_combat_bgm_level(self): if hasattr(self, '_m_has_field_combat_bgm_level'): return self._m_has_field_combat_bgm_level self._m_has_field_combat_bgm_level = ((self.bit_field.length.value >= 4) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_combat_bgm_level', None) @property def has_field_grass_add_hurt(self): if hasattr(self, '_m_has_field_grass_add_hurt'): return self._m_has_field_grass_add_hurt self._m_has_field_grass_add_hurt = ((self.bit_field.length.value >= 6) and ((self.bit_field.bitfield[5] & 4) != 0)) return getattr(self, '_m_has_field_grass_add_hurt', None) @property def has_field_prop_grow_curves(self): if hasattr(self, '_m_has_field_prop_grow_curves'): return self._m_has_field_prop_grow_curves self._m_has_field_prop_grow_curves = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 1) != 0)) return getattr(self, '_m_has_field_prop_grow_curves', None) @property def has_field_prefab_path_ragdoll_hash(self): if hasattr(self, '_m_has_field_prefab_path_ragdoll_hash'): return self._m_has_field_prefab_path_ragdoll_hash self._m_has_field_prefab_path_ragdoll_hash = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 16) != 0)) return getattr(self, '_m_has_field_prefab_path_ragdoll_hash', None) @property def has_field_is_scene_reward(self): if hasattr(self, '_m_has_field_is_scene_reward'): return self._m_has_field_is_scene_reward self._m_has_field_is_scene_reward = ((self.bit_field.length.value >= 2) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_scene_reward', None) @property def has_field_sus2(self): if hasattr(self, '_m_has_field_sus2'): return self._m_has_field_sus2 self._m_has_field_sus2 = ((self.bit_field.length.value >= 1) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sus2', None) @property def has_field_sus5(self): if hasattr(self, '_m_has_field_sus5'): return self._m_has_field_sus5 self._m_has_field_sus5 = ((self.bit_field.length.value >= 7) and ((self.bit_field.bitfield[6] & 32) != 0)) return getattr(self, '_m_has_field_sus5', None) @property def has_field_vision_level(self): if hasattr(self, '_m_has_field_vision_level'): return self._m_has_field_vision_level self._m_has_field_vision_level = ((self.bit_field.length.value >= 3) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_vision_level', None) class ByTargetAltitude(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_target_altitude_type: self.target_altitude_type = Output.EnumTargetAltitudeType(self._io, self, self._root) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def has_field_target_altitude_type(self): if hasattr(self, '_m_has_field_target_altitude_type'): return self._m_has_field_target_altitude_type self._m_has_field_target_altitude_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_altitude_type', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class AddRegionalPlayVarValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_var_type: self.var_type = Output.EnumRegionalPlayVarType(self._io, self, self._root) if self.has_field_add_value: self.add_value = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_add_value(self): if hasattr(self, '_m_has_field_add_value'): return self._m_has_field_add_value self._m_has_field_add_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_add_value', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_var_type(self): if hasattr(self, '_m_has_field_var_type'): return self._m_has_field_var_type self._m_has_field_var_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_var_type', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfEnumAiTargetSystemTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumAiTargetSystemType(self._io, self, self._root)) class BlossomRefreshCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumBlossomRefreshCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class EnumNarratorState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NarratorState, self.data.value) return getattr(self, '_m_value', None) class ConfigMoveStateEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_footprint: self.footprint = Output.ConfigFootprint(self._io, self, self._root) @property def has_field_footprint(self): if hasattr(self, '_m_has_field_footprint'): return self._m_has_field_footprint self._m_has_field_footprint = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_footprint', None) class ConfigCameraSplineBaseTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_length_ratio: self.length_ratio = self._io.read_f4le() if self.has_field_s_list: self.s_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_t_list: self.t_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_length_ratio(self): if hasattr(self, '_m_has_field_length_ratio'): return self._m_has_field_length_ratio self._m_has_field_length_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_length_ratio', None) @property def has_field_s_list(self): if hasattr(self, '_m_has_field_s_list'): return self._m_has_field_s_list self._m_has_field_s_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_s_list', None) @property def has_field_t_list(self): if hasattr(self, '_m_has_field_t_list'): return self._m_has_field_t_list self._m_has_field_t_list = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_t_list', None) class FishExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_id: self.monster_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hp: self.hp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_skill_id: self.skill_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bonus_width: self.bonus_width = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bonus_duration: self.bonus_duration = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_bonus_offset: self.bonus_offset = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_bonus_speed: self.bonus_speed = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_feeler_times: self.feeler_times = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_attract_range: self.attract_range = self._io.read_f4le() if self.has_field_flee_range: self.flee_range = self._io.read_f4le() if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_id_list: self.drop_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_fish_cate_id: self.fish_cate_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_bite_timeout: self.bite_timeout = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_init_pose: self.init_pose = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_compound_id: self.compound_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_bonus_duration(self): if hasattr(self, '_m_has_field_bonus_duration'): return self._m_has_field_bonus_duration self._m_has_field_bonus_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_bonus_duration', None) @property def has_field_compound_id(self): if hasattr(self, '_m_has_field_compound_id'): return self._m_has_field_compound_id self._m_has_field_compound_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_compound_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_fish_cate_id(self): if hasattr(self, '_m_has_field_fish_cate_id'): return self._m_has_field_fish_cate_id self._m_has_field_fish_cate_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_fish_cate_id', None) @property def has_field_monster_id(self): if hasattr(self, '_m_has_field_monster_id'): return self._m_has_field_monster_id self._m_has_field_monster_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_id', None) @property def has_field_feeler_times(self): if hasattr(self, '_m_has_field_feeler_times'): return self._m_has_field_feeler_times self._m_has_field_feeler_times = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_feeler_times', None) @property def has_field_attract_range(self): if hasattr(self, '_m_has_field_attract_range'): return self._m_has_field_attract_range self._m_has_field_attract_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_attract_range', None) @property def has_field_bonus_width(self): if hasattr(self, '_m_has_field_bonus_width'): return self._m_has_field_bonus_width self._m_has_field_bonus_width = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_bonus_width', None) @property def has_field_bonus_speed(self): if hasattr(self, '_m_has_field_bonus_speed'): return self._m_has_field_bonus_speed self._m_has_field_bonus_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_bonus_speed', None) @property def has_field_drop_id_list(self): if hasattr(self, '_m_has_field_drop_id_list'): return self._m_has_field_drop_id_list self._m_has_field_drop_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_drop_id_list', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_skill_id', None) @property def has_field_flee_range(self): if hasattr(self, '_m_has_field_flee_range'): return self._m_has_field_flee_range self._m_has_field_flee_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_flee_range', None) @property def has_field_bonus_offset(self): if hasattr(self, '_m_has_field_bonus_offset'): return self._m_has_field_bonus_offset self._m_has_field_bonus_offset = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_bonus_offset', None) @property def has_field_bite_timeout(self): if hasattr(self, '_m_has_field_bite_timeout'): return self._m_has_field_bite_timeout self._m_has_field_bite_timeout = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_bite_timeout', None) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_init_pose(self): if hasattr(self, '_m_has_field_init_pose'): return self._m_has_field_init_pose self._m_has_field_init_pose = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_init_pose', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hp(self): if hasattr(self, '_m_has_field_hp'): return self._m_has_field_hp self._m_has_field_hp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_hp', None) class EnumRandTaskType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RandTaskType, self.data.value) return getattr(self, '_m_value', None) class RegisterAiActionPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_point_type: self.point_type = Output.EnumActionPointType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigCustomAttackShape(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sphere: self.sphere = Output.ConfigCustomAttackSphere(self._io, self, self._root) if self.has_field_box: self.box = Output.ConfigCustomAttackBox(self._io, self, self._root) if self.has_field_circle: self.circle = Output.ConfigCustomAttackCircle(self._io, self, self._root) @property def has_field_sphere(self): if hasattr(self, '_m_has_field_sphere'): return self._m_has_field_sphere self._m_has_field_sphere = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sphere', None) @property def has_field_box(self): if hasattr(self, '_m_has_field_box'): return self._m_has_field_box self._m_has_field_box = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_box', None) @property def has_field_circle(self): if hasattr(self, '_m_has_field_circle'): return self._m_has_field_circle self._m_has_field_circle = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_circle', None) class EnumDungeonCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DungeonCondType, self.data.value) return getattr(self, '_m_value', None) class ConfigCanChangeAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_normalize_start: self.normalize_start = self._io.read_f4le() if self.has_field_normalize_end: self.normalize_end = self._io.read_f4le() @property def has_field_normalize_start(self): if hasattr(self, '_m_has_field_normalize_start'): return self._m_has_field_normalize_start self._m_has_field_normalize_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_normalize_start', None) @property def has_field_normalize_end(self): if hasattr(self, '_m_has_field_normalize_end'): return self._m_has_field_normalize_end self._m_has_field_normalize_end = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_normalize_end', None) class MichiaeOfferingDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFormulaicMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_control: self.time_control = Output.EnumUgcTimeControlType(self._io, self, self._root) if self.has_field_formula_type: self.formula_type = Output.EnumUgcFormulaType(self._io, self, self._root) if self.has_field_move_mode: self.move_mode = Output.EnumUgcMoveType(self._io, self, self._root) if self.has_field_off_time: self.off_time = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_automatic_move: self.automatic_move = self._io.read_u1() if self.has_field_polar: self.polar = Output.EnumUgcAxialType(self._io, self, self._root) if self.has_field_angle_section: self.angle_section = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_angle_step: self.angle_step = self._io.read_f4le() if self.has_field_is_clock_wise: self.is_clock_wise = self._io.read_u1() if self.has_field_angle_speed: self.angle_speed = self._io.read_f4le() if self.has_field_period: self.period = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_route: self.route = Output.ArrayOfVectorLengthU(self._io, self, self._root) @property def has_field_off_time(self): if hasattr(self, '_m_has_field_off_time'): return self._m_has_field_off_time self._m_has_field_off_time = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_off_time', None) @property def has_field_angle_step(self): if hasattr(self, '_m_has_field_angle_step'): return self._m_has_field_angle_step self._m_has_field_angle_step = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_angle_step', None) @property def has_field_angle_speed(self): if hasattr(self, '_m_has_field_angle_speed'): return self._m_has_field_angle_speed self._m_has_field_angle_speed = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_angle_speed', None) @property def has_field_is_clock_wise(self): if hasattr(self, '_m_has_field_is_clock_wise'): return self._m_has_field_is_clock_wise self._m_has_field_is_clock_wise = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_is_clock_wise', None) @property def has_field_time_control(self): if hasattr(self, '_m_has_field_time_control'): return self._m_has_field_time_control self._m_has_field_time_control = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_time_control', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_polar(self): if hasattr(self, '_m_has_field_polar'): return self._m_has_field_polar self._m_has_field_polar = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_polar', None) @property def has_field_automatic_move(self): if hasattr(self, '_m_has_field_automatic_move'): return self._m_has_field_automatic_move self._m_has_field_automatic_move = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_automatic_move', None) @property def has_field_period(self): if hasattr(self, '_m_has_field_period'): return self._m_has_field_period self._m_has_field_period = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_period', None) @property def has_field_formula_type(self): if hasattr(self, '_m_has_field_formula_type'): return self._m_has_field_formula_type self._m_has_field_formula_type = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_formula_type', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_angle_section(self): if hasattr(self, '_m_has_field_angle_section'): return self._m_has_field_angle_section self._m_has_field_angle_section = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_angle_section', None) @property def has_field_move_mode(self): if hasattr(self, '_m_has_field_move_mode'): return self._m_has_field_move_mode self._m_has_field_move_mode = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_move_mode', None) @property def has_field_route(self): if hasattr(self, '_m_has_field_route'): return self._m_has_field_route self._m_has_field_route = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_route', None) class ConfigUi(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_input_events: self.input_events = Output.DictOfEnumInputEventTypeConfigBaseInputEvent(self._io, self, self._root) if self.has_field_action_groups: self.action_groups = Output.DictOfAuxTypesStringArrayOfInputActionEventLengthU(self._io, self, self._root) if self.has_field_context: self.context = Output.DictOfAuxTypesStringConfigBaseContext(self._io, self, self._root) @property def has_field_input_events(self): if hasattr(self, '_m_has_field_input_events'): return self._m_has_field_input_events self._m_has_field_input_events = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_input_events', None) @property def has_field_action_groups(self): if hasattr(self, '_m_has_field_action_groups'): return self._m_has_field_action_groups self._m_has_field_action_groups = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_groups', None) @property def has_field_context(self): if hasattr(self, '_m_has_field_context'): return self._m_has_field_context self._m_has_field_context = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_context', None) class SkillDragComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumWidgetCameraActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetCameraActionType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesVlqBase128LeSAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSAuxTypesVlqBase128LeS(self._io, self, self._root)) class BaseUtilityAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesStringConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigWwiseString(self._io, self, self._root)) class ConfigFullPreload(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_platform_preload_mapping: self.platform_preload_mapping = Output.ConfigPlatformPreloadMapping(self._io, self, self._root) if self.has_field_common_preload: self.common_preload = Output.ConfigPreload(self._io, self, self._root) if self.has_field_entities_preload: self.entities_preload = Output.DictOfAuxTypesVlqBase128LeUConfigPreload(self._io, self, self._root) @property def has_field_platform_preload_mapping(self): if hasattr(self, '_m_has_field_platform_preload_mapping'): return self._m_has_field_platform_preload_mapping self._m_has_field_platform_preload_mapping = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_platform_preload_mapping', None) @property def has_field_common_preload(self): if hasattr(self, '_m_has_field_common_preload'): return self._m_has_field_common_preload self._m_has_field_common_preload = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_common_preload', None) @property def has_field_entities_preload(self): if hasattr(self, '_m_has_field_entities_preload'): return self._m_has_field_entities_preload self._m_has_field_entities_preload = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_entities_preload', None) class ConfigResourceCollection(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_resource_collection_map: self.resource_collection_map = Output.DictOfAuxTypesVlqBase128LeUConfigResourceCollectionContent(self._io, self, self._root) @property def has_field_resource_collection_map(self): if hasattr(self, '_m_has_field_resource_collection_map'): return self._m_has_field_resource_collection_map self._m_has_field_resource_collection_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_resource_collection_map', None) class EnumGadgetInteractItemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GadgetInteractItemType, self.data.value) return getattr(self, '_m_value', None) class CoopChapterExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_name: self.chapter_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_page_title: self.coop_page_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_sort_id: self.chapter_sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_sort_id: self.avatar_sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chapter_icon: self.chapter_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_unlock_cond: self.unlock_cond = Output.ArrayOfCoopCondConfigLengthS(self._io, self, self._root) if self.has_field_unlock_cond_tips: self.unlock_cond_tips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_material_id: self.open_material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_material_num: self.open_material_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_time_str: self.begin_time_str = AuxTypes.String(self._io, self, self._root) if self.has_field_confidence_value: self.confidence_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_graph_path: self.point_graph_path = AuxTypes.String(self._io, self, self._root) if self.has_field_graph_x_ratio: self.graph_x_ratio = self._io.read_f4le() if self.has_field_graph_y_ratio: self.graph_y_ratio = self._io.read_f4le() @property def has_field_graph_x_ratio(self): if hasattr(self, '_m_has_field_graph_x_ratio'): return self._m_has_field_graph_x_ratio self._m_has_field_graph_x_ratio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_graph_x_ratio', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_avatar_sort_id(self): if hasattr(self, '_m_has_field_avatar_sort_id'): return self._m_has_field_avatar_sort_id self._m_has_field_avatar_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_avatar_sort_id', None) @property def has_field_chapter_sort_id(self): if hasattr(self, '_m_has_field_chapter_sort_id'): return self._m_has_field_chapter_sort_id self._m_has_field_chapter_sort_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_chapter_sort_id', None) @property def has_field_chapter_name(self): if hasattr(self, '_m_has_field_chapter_name'): return self._m_has_field_chapter_name self._m_has_field_chapter_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_chapter_name', None) @property def has_field_open_material_num(self): if hasattr(self, '_m_has_field_open_material_num'): return self._m_has_field_open_material_num self._m_has_field_open_material_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_open_material_num', None) @property def has_field_begin_time_str(self): if hasattr(self, '_m_has_field_begin_time_str'): return self._m_has_field_begin_time_str self._m_has_field_begin_time_str = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_begin_time_str', None) @property def has_field_coop_page_title(self): if hasattr(self, '_m_has_field_coop_page_title'): return self._m_has_field_coop_page_title self._m_has_field_coop_page_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_coop_page_title', None) @property def has_field_point_graph_path(self): if hasattr(self, '_m_has_field_point_graph_path'): return self._m_has_field_point_graph_path self._m_has_field_point_graph_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_point_graph_path', None) @property def has_field_confidence_value(self): if hasattr(self, '_m_has_field_confidence_value'): return self._m_has_field_confidence_value self._m_has_field_confidence_value = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_confidence_value', None) @property def has_field_open_material_id(self): if hasattr(self, '_m_has_field_open_material_id'): return self._m_has_field_open_material_id self._m_has_field_open_material_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_open_material_id', None) @property def has_field_unlock_cond_tips(self): if hasattr(self, '_m_has_field_unlock_cond_tips'): return self._m_has_field_unlock_cond_tips self._m_has_field_unlock_cond_tips = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_unlock_cond_tips', None) @property def has_field_chapter_icon(self): if hasattr(self, '_m_has_field_chapter_icon'): return self._m_has_field_chapter_icon self._m_has_field_chapter_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_chapter_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_graph_y_ratio(self): if hasattr(self, '_m_has_field_graph_y_ratio'): return self._m_has_field_graph_y_ratio self._m_has_field_graph_y_ratio = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_graph_y_ratio', None) @property def has_field_unlock_cond(self): if hasattr(self, '_m_has_field_unlock_cond'): return self._m_has_field_unlock_cond self._m_has_field_unlock_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_unlock_cond', None) class ArrayOfConfigHomeAnimalLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeAnimal(self._io, self, self._root)) class SummerTimeV2dungeonStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ExploreEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigDitherByNormalBetweenCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_detect_dither_range: self.detect_dither_range = self._io.read_f4le() @property def has_field_detect_dither_range(self): if hasattr(self, '_m_has_field_detect_dither_range'): return self._m_has_field_detect_dither_range self._m_has_field_detect_dither_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_detect_dither_range', None) class ArrayOfConfigCanChangeAvatarLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCanChangeAvatar(self._io, self, self._root)) class TryFindBlinkPointByBorn(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_hit_scene_test: self.hit_scene_test = self._io.read_u1() if self.has_field_hit_scene_type: self.hit_scene_type = Output.EnumBlinkHitSceneTestType(self._io, self, self._root) if self.has_field_limit_y: self.limit_y = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_ignore_water: self.ignore_water = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_hit_scene_type(self): if hasattr(self, '_m_has_field_hit_scene_type'): return self._m_has_field_hit_scene_type self._m_has_field_hit_scene_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_hit_scene_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_hit_scene_test(self): if hasattr(self, '_m_has_field_hit_scene_test'): return self._m_has_field_hit_scene_test self._m_has_field_hit_scene_test = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_hit_scene_test', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_limit_y(self): if hasattr(self, '_m_has_field_limit_y'): return self._m_has_field_limit_y self._m_has_field_limit_y = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_limit_y', None) @property def has_field_ignore_water(self): if hasattr(self, '_m_has_field_ignore_water'): return self._m_has_field_ignore_water self._m_has_field_ignore_water = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_ignore_water', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_born', None) class EnumTextLanguageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TextLanguageType, self.data.value) return getattr(self, '_m_value', None) class NewActivityPreviewConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro_title: self.intro_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_intro_content: self.intro_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pre_quest_id: self.pre_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_middle_quest_id_list: self.middle_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_middle_quest_finish_id_list: self.middle_quest_finish_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_quest_id: self.open_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id: self.push_tips_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_main_quest_id_list: self.open_main_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pre_main_quest_id_list: self.pre_main_quest_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_pre_activity_condition: self.pre_activity_condition = Output.ArrayOfPreviewActivityCondLengthS(self._io, self, self._root) if self.has_field_is_blocked: self.is_blocked = self._io.read_u1() @property def has_field_open_main_quest_id_list(self): if hasattr(self, '_m_has_field_open_main_quest_id_list'): return self._m_has_field_open_main_quest_id_list self._m_has_field_open_main_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_open_main_quest_id_list', None) @property def has_field_pre_activity_condition(self): if hasattr(self, '_m_has_field_pre_activity_condition'): return self._m_has_field_pre_activity_condition self._m_has_field_pre_activity_condition = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_pre_activity_condition', None) @property def has_field_intro_title(self): if hasattr(self, '_m_has_field_intro_title'): return self._m_has_field_intro_title self._m_has_field_intro_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_intro_title', None) @property def has_field_pre_main_quest_id_list(self): if hasattr(self, '_m_has_field_pre_main_quest_id_list'): return self._m_has_field_pre_main_quest_id_list self._m_has_field_pre_main_quest_id_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_pre_main_quest_id_list', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_is_blocked(self): if hasattr(self, '_m_has_field_is_blocked'): return self._m_has_field_is_blocked self._m_has_field_is_blocked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_is_blocked', None) @property def has_field_intro_content(self): if hasattr(self, '_m_has_field_intro_content'): return self._m_has_field_intro_content self._m_has_field_intro_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_intro_content', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_open_quest_id(self): if hasattr(self, '_m_has_field_open_quest_id'): return self._m_has_field_open_quest_id self._m_has_field_open_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_open_quest_id', None) @property def has_field_push_tips_id(self): if hasattr(self, '_m_has_field_push_tips_id'): return self._m_has_field_push_tips_id self._m_has_field_push_tips_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_push_tips_id', None) @property def has_field_middle_quest_id_list(self): if hasattr(self, '_m_has_field_middle_quest_id_list'): return self._m_has_field_middle_quest_id_list self._m_has_field_middle_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_middle_quest_id_list', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_pre_quest_id(self): if hasattr(self, '_m_has_field_pre_quest_id'): return self._m_has_field_pre_quest_id self._m_has_field_pre_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_pre_quest_id', None) @property def has_field_middle_quest_finish_id_list(self): if hasattr(self, '_m_has_field_middle_quest_finish_id_list'): return self._m_has_field_middle_quest_finish_id_list self._m_has_field_middle_quest_finish_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_middle_quest_finish_id_list', None) class TowerSkipFloorExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_prev_level_index: self.prev_level_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cur_level_index: self.cur_level_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_prev_level_index(self): if hasattr(self, '_m_has_field_prev_level_index'): return self._m_has_field_prev_level_index self._m_has_field_prev_level_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_prev_level_index', None) @property def has_field_cur_level_index(self): if hasattr(self, '_m_has_field_cur_level_index'): return self._m_has_field_cur_level_index self._m_has_field_cur_level_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cur_level_index', None) class ShopRotateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumMiracleTagLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumMiracleTag(self._io, self, self._root)) class EnumModifierTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ModifierTag, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringF4(self._io, self, self._root)) class CustomGadgetNodeSlot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_named_transform: self.named_transform = AuxTypes.String(self._io, self, self._root) if self.has_field_slot_type: self.slot_type = Output.EnumCustomGadgetNodeSlotType(self._io, self, self._root) if self.has_field_slot_config_id: self.slot_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_named_transform(self): if hasattr(self, '_m_has_field_named_transform'): return self._m_has_field_named_transform self._m_has_field_named_transform = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_named_transform', None) @property def has_field_slot_type(self): if hasattr(self, '_m_has_field_slot_type'): return self._m_has_field_slot_type self._m_has_field_slot_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_slot_type', None) @property def has_field_slot_config_id(self): if hasattr(self, '_m_has_field_slot_config_id'): return self._m_has_field_slot_config_id self._m_has_field_slot_config_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_slot_config_id', None) class ActivityChessCardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag: self.tag = Output.EnumChessCardTag(self._io, self, self._root) if self.has_field_need_chess_level: self.need_chess_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_name: self.card_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_desc: self.extra_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_desc2: self.extra_desc2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param_list: self.desc_param_list = Output.ArrayOfArrayOfF4LengthULengthU(self._io, self, self._root) if self.has_field_desc_param_superposition_list: self.desc_param_superposition_list = Output.ArrayOfU1LengthU(self._io, self, self._root) if self.has_field_is_disused: self.is_disused = self._io.read_u1() if self.has_field_card_numerical_modification_type: self.card_numerical_modification_type = Output.EnumChessCardNumericalModificationType(self._io, self, self._root) if self.has_field_card_numerical_modification_mode: self.card_numerical_modification_mode = Output.EnumChessCardNumericalModificationMode(self._io, self, self._root) if self.has_field_card_numerical_modification_value: self.card_numerical_modification_value = self._io.read_f4le() if self.has_field_cost_points: self.cost_points = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_card_type: self.card_type = Output.EnumChessCardType(self._io, self, self._root) if self.has_field_card_quality_type: self.card_quality_type = Output.EnumChessCardQualityType(self._io, self, self._root) if self.has_field_card_count: self.card_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect: self.effect = Output.ChessCardEffect(self._io, self, self._root) if self.has_field_curse_weight: self.curse_weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_can_attach_curse: self.is_can_attach_curse = self._io.read_u1() if self.has_field_is_remove_on_pick: self.is_remove_on_pick = self._io.read_u1() if self.has_field_is_show_on_pick: self.is_show_on_pick = self._io.read_u1() if self.has_field_extra_effect_list: self.extra_effect_list = Output.ArrayOfChessCardEffectLengthS(self._io, self, self._root) @property def has_field_need_chess_level(self): if hasattr(self, '_m_has_field_need_chess_level'): return self._m_has_field_need_chess_level self._m_has_field_need_chess_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_need_chess_level', None) @property def has_field_card_name(self): if hasattr(self, '_m_has_field_card_name'): return self._m_has_field_card_name self._m_has_field_card_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_card_name', None) @property def has_field_cost_points(self): if hasattr(self, '_m_has_field_cost_points'): return self._m_has_field_cost_points self._m_has_field_cost_points = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_cost_points', None) @property def has_field_is_can_attach_curse(self): if hasattr(self, '_m_has_field_is_can_attach_curse'): return self._m_has_field_is_can_attach_curse self._m_has_field_is_can_attach_curse = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_is_can_attach_curse', None) @property def has_field_effect(self): if hasattr(self, '_m_has_field_effect'): return self._m_has_field_effect self._m_has_field_effect = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_effect', None) @property def has_field_card_numerical_modification_mode(self): if hasattr(self, '_m_has_field_card_numerical_modification_mode'): return self._m_has_field_card_numerical_modification_mode self._m_has_field_card_numerical_modification_mode = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_mode', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_number', None) @property def has_field_card_numerical_modification_value(self): if hasattr(self, '_m_has_field_card_numerical_modification_value'): return self._m_has_field_card_numerical_modification_value self._m_has_field_card_numerical_modification_value = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_value', None) @property def has_field_is_remove_on_pick(self): if hasattr(self, '_m_has_field_is_remove_on_pick'): return self._m_has_field_is_remove_on_pick self._m_has_field_is_remove_on_pick = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_is_remove_on_pick', None) @property def has_field_is_show_on_pick(self): if hasattr(self, '_m_has_field_is_show_on_pick'): return self._m_has_field_is_show_on_pick self._m_has_field_is_show_on_pick = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_is_show_on_pick', None) @property def has_field_card_numerical_modification_type(self): if hasattr(self, '_m_has_field_card_numerical_modification_type'): return self._m_has_field_card_numerical_modification_type self._m_has_field_card_numerical_modification_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_card_numerical_modification_type', None) @property def has_field_desc_param_superposition_list(self): if hasattr(self, '_m_has_field_desc_param_superposition_list'): return self._m_has_field_desc_param_superposition_list self._m_has_field_desc_param_superposition_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_desc_param_superposition_list', None) @property def has_field_curse_weight(self): if hasattr(self, '_m_has_field_curse_weight'): return self._m_has_field_curse_weight self._m_has_field_curse_weight = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_curse_weight', None) @property def has_field_desc_param_list(self): if hasattr(self, '_m_has_field_desc_param_list'): return self._m_has_field_desc_param_list self._m_has_field_desc_param_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_desc_param_list', None) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_tag', None) @property def has_field_extra_desc2(self): if hasattr(self, '_m_has_field_extra_desc2'): return self._m_has_field_extra_desc2 self._m_has_field_extra_desc2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_extra_desc2', None) @property def has_field_card_count(self): if hasattr(self, '_m_has_field_card_count'): return self._m_has_field_card_count self._m_has_field_card_count = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_card_count', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_extra_desc(self): if hasattr(self, '_m_has_field_extra_desc'): return self._m_has_field_extra_desc self._m_has_field_extra_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_extra_desc', None) @property def has_field_card_type(self): if hasattr(self, '_m_has_field_card_type'): return self._m_has_field_card_type self._m_has_field_card_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_card_type', None) @property def has_field_extra_effect_list(self): if hasattr(self, '_m_has_field_extra_effect_list'): return self._m_has_field_extra_effect_list self._m_has_field_extra_effect_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_extra_effect_list', None) @property def has_field_is_disused(self): if hasattr(self, '_m_has_field_is_disused'): return self._m_has_field_is_disused self._m_has_field_is_disused = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_disused', None) @property def has_field_card_quality_type(self): if hasattr(self, '_m_has_field_card_quality_type'): return self._m_has_field_card_quality_type self._m_has_field_card_quality_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_card_quality_type', None) class TargetPosToSelfPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMusicUInt32inequalityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicUInt32condition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class CoopNodeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestGuideLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestGuideLayer, self.data.value) return getattr(self, '_m_value', None) class AnimatorEventPatternFullInspector(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityShopSheetCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumRegionSearchCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RegionSearchCondType, self.data.value) return getattr(self, '_m_value', None) class AvatarDoBlink(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_prefer_input: self.prefer_input = self._io.read_u1() if self.has_field_distance: self.distance = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_distance', None) @property def has_field_prefer_input(self): if hasattr(self, '_m_has_field_prefer_input'): return self._m_has_field_prefer_input self._m_has_field_prefer_input = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_prefer_input', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigEffectPool(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_particle_system_budget_size: self.particle_system_budget_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_particle_system_budget_size_low_memory: self.particle_system_budget_size_low_memory = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_particle_system_budget_size_mid_memory: self.particle_system_budget_size_mid_memory = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effectpool_budget_size: self.effectpool_budget_size = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_release_for_budget_time_threshold: self.release_for_budget_time_threshold = self._io.read_f4le() if self.has_field_release_for_budget_time_threshold_low_memory: self.release_for_budget_time_threshold_low_memory = self._io.read_f4le() if self.has_field_release_for_budget_time_threshold_mid_memory: self.release_for_budget_time_threshold_mid_memory = self._io.read_f4le() if self.has_field_release_budget_time_threshold_per_frame: self.release_budget_time_threshold_per_frame = self._io.read_f4le() if self.has_field_pool_items: self.pool_items = Output.DictOfAuxTypesStringConfigEffectPoolItem(self._io, self, self._root) @property def has_field_effectpool_budget_size(self): if hasattr(self, '_m_has_field_effectpool_budget_size'): return self._m_has_field_effectpool_budget_size self._m_has_field_effectpool_budget_size = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_effectpool_budget_size', None) @property def has_field_release_budget_time_threshold_per_frame(self): if hasattr(self, '_m_has_field_release_budget_time_threshold_per_frame'): return self._m_has_field_release_budget_time_threshold_per_frame self._m_has_field_release_budget_time_threshold_per_frame = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_release_budget_time_threshold_per_frame', None) @property def has_field_particle_system_budget_size(self): if hasattr(self, '_m_has_field_particle_system_budget_size'): return self._m_has_field_particle_system_budget_size self._m_has_field_particle_system_budget_size = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_particle_system_budget_size', None) @property def has_field_pool_items(self): if hasattr(self, '_m_has_field_pool_items'): return self._m_has_field_pool_items self._m_has_field_pool_items = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_pool_items', None) @property def has_field_release_for_budget_time_threshold_mid_memory(self): if hasattr(self, '_m_has_field_release_for_budget_time_threshold_mid_memory'): return self._m_has_field_release_for_budget_time_threshold_mid_memory self._m_has_field_release_for_budget_time_threshold_mid_memory = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_release_for_budget_time_threshold_mid_memory', None) @property def has_field_release_for_budget_time_threshold_low_memory(self): if hasattr(self, '_m_has_field_release_for_budget_time_threshold_low_memory'): return self._m_has_field_release_for_budget_time_threshold_low_memory self._m_has_field_release_for_budget_time_threshold_low_memory = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_release_for_budget_time_threshold_low_memory', None) @property def has_field_particle_system_budget_size_mid_memory(self): if hasattr(self, '_m_has_field_particle_system_budget_size_mid_memory'): return self._m_has_field_particle_system_budget_size_mid_memory self._m_has_field_particle_system_budget_size_mid_memory = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_particle_system_budget_size_mid_memory', None) @property def has_field_release_for_budget_time_threshold(self): if hasattr(self, '_m_has_field_release_for_budget_time_threshold'): return self._m_has_field_release_for_budget_time_threshold self._m_has_field_release_for_budget_time_threshold = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_release_for_budget_time_threshold', None) @property def has_field_particle_system_budget_size_low_memory(self): if hasattr(self, '_m_has_field_particle_system_budget_size_low_memory'): return self._m_has_field_particle_system_budget_size_low_memory self._m_has_field_particle_system_budget_size_low_memory = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_particle_system_budget_size_low_memory', None) class BornRandom(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigJudgeAvatarWeaponType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigJudgeNodeBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weapon_type: self.weapon_type = AuxTypes.String(self._io, self, self._root) @property def has_field_weapon_type(self): if hasattr(self, '_m_has_field_weapon_type'): return self._m_has_field_weapon_type self._m_has_field_weapon_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weapon_type', None) @property def node_id(self): if hasattr(self, '_m_node_id'): return self._m_node_id self._m_node_id = self.base.node_id return getattr(self, '_m_node_id', None) class ArrayOfConfigAbilityFrameDataLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigAbilityFrameData(self._io, self, self._root)) class KvpOfDictAuxTypesStringArrayOfInputActionEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfInputActionEventLengthU(self._io, self, self._root) class PsActivitiesSubTaskConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumSettleShowTypeLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumSettleShowType(self._io, self, self._root)) class DialogSelectTimeOutExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoActionByElementReactionMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_range: self.range = self._io.read_f4le() if self.has_field_entity_types: self.entity_types = Output.ArrayOfEnumEntityTypeLengthU(self._io, self, self._root) if self.has_field_reaction_types: self.reaction_types = Output.ArrayOfEnumElementReactionTypeLengthU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_range(self): if hasattr(self, '_m_has_field_range'): return self._m_has_field_range self._m_has_field_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_range', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_actions', None) @property def has_field_reaction_types(self): if hasattr(self, '_m_has_field_reaction_types'): return self._m_has_field_reaction_types self._m_has_field_reaction_types = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_reaction_types', None) @property def has_field_entity_types(self): if hasattr(self, '_m_has_field_entity_types'): return self._m_has_field_entity_types self._m_has_field_entity_types = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_entity_types', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class KvpOfDictAuxTypesStringArrayOfConfigEntityBlackGrpLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfConfigEntityBlackGrpLengthU(self._io, self, self._root) class ConfigHomeFishpond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_max_fish_count: self.max_fish_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fish_born_pos_list: self.fish_born_pos_list = Output.ArrayOfConfigHomeCommonPosLengthU(self._io, self, self._root) @property def has_field_max_fish_count(self): if hasattr(self, '_m_has_field_max_fish_count'): return self._m_has_field_max_fish_count self._m_has_field_max_fish_count = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_fish_count', None) @property def has_field_fish_born_pos_list(self): if hasattr(self, '_m_has_field_fish_born_pos_list'): return self._m_has_field_fish_born_pos_list self._m_has_field_fish_born_pos_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fish_born_pos_list', None) class DispConfigAbilityAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 120: self.data = Output.HideUiBillBoard(self._io, self, self._root) elif _on == 141: self.data = Output.EnableAiStealthy(self._io, self, self._root) elif _on == 236: self.data = Output.KillPlayEntity(self._io, self, self._root) elif _on == 243: self.data = Output.SetChargeRatio(self._io, self, self._root) elif _on == 239: self.data = Output.FireUiEffect(self._io, self, self._root) elif _on == 93: self.data = Output.TriggerAuxWeaponTrans(self._io, self, self._root) elif _on == 118: self.data = Output.GenerateElemBall(self._io, self, self._root) elif _on == 246: self.data = Output.EnablePositionSynchronization(self._io, self, self._root) elif _on == 159: self.data = Output.RegistToStageScript(self._io, self, self._root) elif _on == 194: self.data = Output.ResetAvatarHitBuckets(self._io, self, self._root) elif _on == 184: self.data = Output.EnableCameraDof(self._io, self, self._root) elif _on == 105: self.data = Output.SetPoseFloat(self._io, self, self._root) elif _on == 142: self.data = Output.UnlockSkill(self._io, self, self._root) elif _on == 14: self.data = Output.EntityDoSkill(self._io, self, self._root) elif _on == 61: self.data = Output.LoseHp(self._io, self, self._root) elif _on == 10: self.data = Output.FireEffectToTarget(self._io, self, self._root) elif _on == 112: self.data = Output.DoBlink(self._io, self, self._root) elif _on == 177: self.data = Output.UpdateReactionDamage(self._io, self, self._root) elif _on == 163: self.data = Output.ResetEnviroEular(self._io, self, self._root) elif _on == 257: self.data = Output.ShowTextMap(self._io, self, self._root) elif _on == 17: self.data = Output.AvatarEnterViewBias(self._io, self, self._root) elif _on == 260: self.data = Output.PushInterActionByConfigPath(self._io, self, self._root) elif _on == 131: self.data = Output.FireAiSoundEvent(self._io, self, self._root) elif _on == 219: self.data = Output.ReviveElemEnergy(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigAbilityAction(self._io, self, self._root) elif _on == 167: self.data = Output.ShowUiCombatBar(self._io, self, self._root) elif _on == 146: self.data = Output.PlayEmojiBubble(self._io, self, self._root) elif _on == 220: self.data = Output.AddClimateMeter(self._io, self, self._root) elif _on == 47: self.data = Output.SetSystemValueToOverrideMap(self._io, self, self._root) elif _on == 136: self.data = Output.RemoveVelocityForce(self._io, self, self._root) elif _on == 73: self.data = Output.ActCameraRadialBlur(self._io, self, self._root) elif _on == 4: self.data = Output.AttachModifier(self._io, self, self._root) elif _on == 42: self.data = Output.SetGlobalValueList(self._io, self, self._root) elif _on == 46: self.data = Output.SetCrystalShieldHpToOverrideMap(self._io, self, self._root) elif _on == 81: self.data = Output.TriggerBullet(self._io, self, self._root) elif _on == 295: self.data = Output.CreateGadget(self._io, self, self._root) elif _on == 169: self.data = Output.AddServerBuff(self._io, self, self._root) elif _on == 162: self.data = Output.TriggerPlayerDie(self._io, self, self._root) elif _on == 214: self.data = Output.UseSkillEliteSet(self._io, self, self._root) elif _on == 116: self.data = Output.EnablePushColliderName(self._io, self, self._root) elif _on == 39: self.data = Output.SetTargetNumToGlobalValue(self._io, self, self._root) elif _on == 60: self.data = Output.HealHp(self._io, self, self._root) elif _on == 211: self.data = Output.DoWatcherSystemAction(self._io, self, self._root) elif _on == 119: self.data = Output.Randomed(self._io, self, self._root) elif _on == 224: self.data = Output.EnableAvatarMoveOnWater(self._io, self, self._root) elif _on == 264: self.data = Output.ClearTile(self._io, self, self._root) elif _on == 24: self.data = Output.ControlEmotion(self._io, self, self._root) elif _on == 244: self.data = Output.EnableLightCoreComponent(self._io, self, self._root) elif _on == 230: self.data = Output.SetExtraAbilityState(self._io, self, self._root) elif _on == 289: self.data = Output.ElementAttachForActivityGacha(self._io, self, self._root) elif _on == 35: self.data = Output.AddGlobalValue(self._io, self, self._root) elif _on == 218: self.data = Output.AddGlobalValueToTarget(self._io, self, self._root) elif _on == 249: self.data = Output.AddChargeBarValue(self._io, self, self._root) elif _on == 6: self.data = Output.FireEffect(self._io, self, self._root) elif _on == 62: self.data = Output.EnableRocketJump(self._io, self, self._root) elif _on == 20: self.data = Output.AvatarCameraParam(self._io, self, self._root) elif _on == 251: self.data = Output.SetUiCombatBarSpark(self._io, self, self._root) elif _on == 32: self.data = Output.AttachEffect(self._io, self, self._root) elif _on == 7: self.data = Output.FireEffectFirework(self._io, self, self._root) elif _on == 202: self.data = Output.ResetAiThreatBroadcastRange(self._io, self, self._root) elif _on == 273: self.data = Output.TriggerSetShadowRamp(self._io, self, self._root) elif _on == 266: self.data = Output.FireFishingEvent(self._io, self, self._root) elif _on == 296: self.data = Output.CreateItem(self._io, self, self._root) elif _on == 113: self.data = Output.DoBlinkByGlobalPos(self._io, self, self._root) elif _on == 284: self.data = Output.HideGadgetBubble(self._io, self, self._root) elif _on == 287: self.data = Output.SetLogicStateValue(self._io, self, self._root) elif _on == 121: self.data = Output.SendEffectTrigger(self._io, self, self._root) elif _on == 288: self.data = Output.ForceEnableShakeOffButton(self._io, self, self._root) elif _on == 96: self.data = Output.TriggerSetCastShadow(self._io, self, self._root) elif _on == 191: self.data = Output.SetSurroundAnchor(self._io, self, self._root) elif _on == 1: self.data = Output.ApplyModifier(self._io, self, self._root) elif _on == 55: self.data = Output.PushPos(self._io, self, self._root) elif _on == 27: self.data = Output.TurnDirectionToPos(self._io, self, self._root) elif _on == 209: self.data = Output.DungeonFogEffects(self._io, self, self._root) elif _on == 150: self.data = Output.SetPaimonLookAtCamera(self._io, self, self._root) elif _on == 294: self.data = Output.ReviveAvatar(self._io, self, self._root) elif _on == 97: self.data = Output.TriggerSetPassThrough(self._io, self, self._root) elif _on == 77: self.data = Output.SetAnimatorTrigger(self._io, self, self._root) elif _on == 106: self.data = Output.TriggerFaceAnimation(self._io, self, self._root) elif _on == 233: self.data = Output.ServerLuaCall(self._io, self, self._root) elif _on == 13: self.data = Output.AvatarShareCdSkillStart(self._io, self, self._root) elif _on == 252: self.data = Output.SetUiCombatBarAsh(self._io, self, self._root) elif _on == 285: self.data = Output.RunGm(self._io, self, self._root) elif _on == 145: self.data = Output.SetCanDieImmediately(self._io, self, self._root) elif _on == 52: self.data = Output.AddGlobalPos(self._io, self, self._root) elif _on == 56: self.data = Output.ClearPos(self._io, self, self._root) elif _on == 101: self.data = Output.TriggerSetChestLock(self._io, self, self._root) elif _on == 144: self.data = Output.RemoveAvatarSkillInfo(self._io, self, self._root) elif _on == 127: self.data = Output.EnablePartControl(self._io, self, self._root) elif _on == 100: self.data = Output.TriggerTaunt(self._io, self, self._root) elif _on == 253: self.data = Output.RefreshUiCombatBarLayout(self._io, self, self._root) elif _on == 45: self.data = Output.SetOverrideMapValue(self._io, self, self._root) elif _on == 87: self.data = Output.KillGadget(self._io, self, self._root) elif _on == 149: self.data = Output.GuidePaimonDisappearEnd(self._io, self, self._root) elif _on == 115: self.data = Output.EnableHitBoxByName(self._io, self, self._root) elif _on == 66: self.data = Output.TriggerAbility(self._io, self, self._root) elif _on == 91: self.data = Output.TriggerThrowEquipPart(self._io, self, self._root) elif _on == 107: self.data = Output.EnableCrashDamage(self._io, self, self._root) elif _on == 262: self.data = Output.CreateTile(self._io, self, self._root) elif _on == 143: self.data = Output.AddAvatarSkillInfo(self._io, self, self._root) elif _on == 267: self.data = Output.SetOvergrowDamgeToOverrideMap(self._io, self, self._root) elif _on == 234: self.data = Output.DoWidgetSystemAction(self._io, self, self._root) elif _on == 89: self.data = Output.TriggerAudio(self._io, self, self._root) elif _on == 245: self.data = Output.ServerMonsterLog(self._io, self, self._root) elif _on == 286: self.data = Output.AddLogicStateValue(self._io, self, self._root) elif _on == 104: self.data = Output.SetPoseInt(self._io, self, self._root) elif _on == 98: self.data = Output.TriggerSetRenderersEnable(self._io, self, self._root) elif _on == 280: self.data = Output.TriggerUgcGadgetMove(self._io, self, self._root) elif _on == 216: self.data = Output.FixedAvatarRushMove(self._io, self, self._root) elif _on == 85: self.data = Output.CreateEntity(self._io, self, self._root) elif _on == 201: self.data = Output.IssueCommand(self._io, self, self._root) elif _on == 292: self.data = Output.ClearLocalGadgets(self._io, self, self._root) elif _on == 197: self.data = Output.ReleaseAiActionPoint(self._io, self, self._root) elif _on == 11: self.data = Output.FireHitEffect(self._io, self, self._root) elif _on == 210: self.data = Output.DoTileAction(self._io, self, self._root) elif _on == 67: self.data = Output.TriggerCrystalLinkAbility(self._io, self, self._root) elif _on == 69: self.data = Output.RemoveModifier(self._io, self, self._root) elif _on == 95: self.data = Output.TriggerSetVisible(self._io, self, self._root) elif _on == 137: self.data = Output.ExecuteGroupTrigger(self._io, self, self._root) elif _on == 12: self.data = Output.AvatarSkillStart(self._io, self, self._root) elif _on == 59: self.data = Output.HealSp(self._io, self, self._root) elif _on == 88: self.data = Output.KillSelf(self._io, self, self._root) elif _on == 208: self.data = Output.CallLuaTask(self._io, self, self._root) elif _on == 161: self.data = Output.CalcDvalinS04rebornPoint(self._io, self, self._root) elif _on == 138: self.data = Output.ReTriggerAiSkillInitialCd(self._io, self, self._root) elif _on == 58: self.data = Output.DamageByAttackValue(self._io, self, self._root) elif _on == 3: self.data = Output.ApplyLevelModifier(self._io, self, self._root) elif _on == 248: self.data = Output.DeductStamina(self._io, self, self._root) elif _on == 192: self.data = Output.SetCombatFixedMovePoint(self._io, self, self._root) elif _on == 126: self.data = Output.EnableHeadControl(self._io, self, self._root) elif _on == 165: self.data = Output.SetSubWeaponEmissionScaler(self._io, self, self._root) elif _on == 5: self.data = Output.RemoveUniqueModifier(self._io, self, self._root) elif _on == 33: self.data = Output.AttachEffectFirework(self._io, self, self._root) elif _on == 103: self.data = Output.SetPoseBool(self._io, self, self._root) elif _on == 293: self.data = Output.Predicated(self._io, self, self._root) elif _on == 205: self.data = Output.UseItem(self._io, self, self._root) elif _on == 99: self.data = Output.TriggerHideWeapon(self._io, self, self._root) elif _on == 82: self.data = Output.TriggerAttackEvent(self._io, self, self._root) elif _on == 185: self.data = Output.EnableHitAutoRedirect(self._io, self, self._root) elif _on == 86: self.data = Output.TryTriggerPlatformStartMove(self._io, self, self._root) elif _on == 180: self.data = Output.SetWeaponAttachPointRealName(self._io, self, self._root) elif _on == 283: self.data = Output.ShowGadgetBubble(self._io, self, self._root) elif _on == 156: self.data = Output.ToNearstAnchorPoint(self._io, self, self._root) elif _on == 125: self.data = Output.ForceInitMassiveEntity(self._io, self, self._root) elif _on == 19: self.data = Output.AvatarExitClimb(self._io, self, self._root) elif _on == 203: self.data = Output.SetAiHitFeeling(self._io, self, self._root) elif _on == 84: self.data = Output.EnableWetElectricHitBox(self._io, self, self._root) elif _on == 63: self.data = Output.ForceTriggerJump(self._io, self, self._root) elif _on == 186: self.data = Output.ClearEndura(self._io, self, self._root) elif _on == 51: self.data = Output.SetGlobalPos(self._io, self, self._root) elif _on == 23: self.data = Output.PlayEmoSync(self._io, self, self._root) elif _on == 83: self.data = Output.TriggerAttackTargetMapEvent(self._io, self, self._root) elif _on == 221: self.data = Output.ResetClimateMeter(self._io, self, self._root) elif _on == 227: self.data = Output.EquipAffixStart(self._io, self, self._root) elif _on == 188: self.data = Output.ResetAiAttackTarget(self._io, self, self._root) elif _on == 48: self.data = Output.SetGlobalValueByTargetDistance(self._io, self, self._root) elif _on == 237: self.data = Output.DummyAction(self._io, self, self._root) elif _on == 153: self.data = Output.SetPaimonTempOffset(self._io, self, self._root) elif _on == 178: self.data = Output.ExecuteGadgetLua(self._io, self, self._root) elif _on == 123: self.data = Output.ChangeFollowDampTime(self._io, self, self._root) elif _on == 78: self.data = Output.ResetAnimatorTrigger(self._io, self, self._root) elif _on == 53: self.data = Output.ClearGlobalPos(self._io, self, self._root) elif _on == 15: self.data = Output.AvatarEnterFocus(self._io, self, self._root) elif _on == 160: self.data = Output.SyncToStageScript(self._io, self, self._root) elif _on == 174: self.data = Output.ResetAbilitySpecial(self._io, self, self._root) elif _on == 176: self.data = Output.ShowReminder(self._io, self, self._root) elif _on == 8: self.data = Output.FireSubEmitterEffect(self._io, self, self._root) elif _on == 166: self.data = Output.EnterCameraLock(self._io, self, self._root) elif _on == 38: self.data = Output.CopyGlobalValue(self._io, self, self._root) elif _on == 114: self.data = Output.AvatarDoBlink(self._io, self, self._root) elif _on == 290: self.data = Output.ModifySkiffPhysicsParam(self._io, self, self._root) elif _on == 259: self.data = Output.EnableWeatherLock(self._io, self, self._root) elif _on == 181: self.data = Output.SetAvatarCanShakeOff(self._io, self, self._root) elif _on == 40: self.data = Output.GetHealAmountToGlobalValue(self._io, self, self._root) elif _on == 207: self.data = Output.SetEntityScale(self._io, self, self._root) elif _on == 204: self.data = Output.SetVelocityIgnoreAirGy(self._io, self, self._root) elif _on == 148: self.data = Output.EnableBulletCollisionPluginTrigger(self._io, self, self._root) elif _on == 158: self.data = Output.SetDvalinS01flyState(self._io, self, self._root) elif _on == 117: self.data = Output.EnableSceneTransformByName(self._io, self, self._root) elif _on == 64: self.data = Output.EnableAfterImage(self._io, self, self._root) elif _on == 152: self.data = Output.SetPaimonLookAtAvatar(self._io, self, self._root) elif _on == 65: self.data = Output.ActTimeSlow(self._io, self, self._root) elif _on == 276: self.data = Output.AttackByEnergy(self._io, self, self._root) elif _on == 269: self.data = Output.SendEvtElectricCoreMoveInterrupt(self._io, self, self._root) elif _on == 94: self.data = Output.TriggerGadgetInteractive(self._io, self, self._root) elif _on == 217: self.data = Output.AttachElementTypeResistance(self._io, self, self._root) elif _on == 281: self.data = Output.ServerLuaTriggerEvent(self._io, self, self._root) elif _on == 263: self.data = Output.DestroyTile(self._io, self, self._root) elif _on == 44: self.data = Output.SetRandomOverrideMapValue(self._io, self, self._root) elif _on == 76: self.data = Output.SetAnimatorFloat(self._io, self, self._root) elif _on == 109: self.data = Output.TryFindBlinkPoint(self._io, self, self._root) elif _on == 241: self.data = Output.SetSkillAnchor(self._io, self, self._root) elif _on == 231: self.data = Output.UpdateUidValue(self._io, self, self._root) elif _on == 206: self.data = Output.Repeated(self._io, self, self._root) elif _on == 79: self.data = Output.SetMaterialParamFloatByTransform(self._io, self, self._root) elif _on == 57: self.data = Output.GetPos(self._io, self, self._root) elif _on == 140: self.data = Output.SetAiSkillGcd(self._io, self, self._root) elif _on == 226: self.data = Output.SyncEntityPositionByNormalizedTime(self._io, self, self._root) elif _on == 274: self.data = Output.SectorCityManeuver(self._io, self, self._root) elif _on == 122: self.data = Output.SendEffectTriggerToLineEffect(self._io, self, self._root) elif _on == 179: self.data = Output.SetWeaponBindState(self._io, self, self._root) elif _on == 9: self.data = Output.FireEffectForStorm(self._io, self, self._root) elif _on == 195: self.data = Output.SetAiSkillCdMultiplier(self._io, self, self._root) elif _on == 268: self.data = Output.SendEvtElectricCoreMoveEnterP1(self._io, self, self._root) elif _on == 172: self.data = Output.ModifyExtraSkillCd(self._io, self, self._root) elif _on == 130: self.data = Output.AttachAbilityStateResistance(self._io, self, self._root) elif _on == 187: self.data = Output.RushMove(self._io, self, self._root) elif _on == 240: self.data = Output.AttachUiEffect(self._io, self, self._root) elif _on == 21: self.data = Output.AvatarEnterCameraShot(self._io, self, self._root) elif _on == 225: self.data = Output.ChangeEnviroWeather(self._io, self, self._root) elif _on == 238: self.data = Output.BanEntityMark(self._io, self, self._root) elif _on == 232: self.data = Output.ForceUseSkillSuccess(self._io, self, self._root) elif _on == 229: self.data = Output.SetExtraAbilityEnable(self._io, self, self._root) elif _on == 279: self.data = Output.AddRegionalPlayVarValue(self._io, self, self._root) elif _on == 258: self.data = Output.FireChargeBarEffect(self._io, self, self._root) elif _on == 235: self.data = Output.ChangeGadgetUiInteractHint(self._io, self, self._root) elif _on == 275: self.data = Output.WidgetSkillStart(self._io, self, self._root) elif _on == 170: self.data = Output.RemoveServerBuff(self._io, self, self._root) elif _on == 37: self.data = Output.MultiplyGlobalValue(self._io, self, self._root) elif _on == 242: self.data = Output.AddChargeValue(self._io, self, self._root) elif _on == 256: self.data = Output.KillServerGadget(self._io, self, self._root) elif _on == 199: self.data = Output.SetNeuronMute(self._io, self, self._root) elif _on == 164: self.data = Output.SetEmissionScaler(self._io, self, self._root) elif _on == 182: self.data = Output.EnableMainInterface(self._io, self, self._root) elif _on == 108: self.data = Output.SetCrashDamage(self._io, self, self._root) elif _on == 271: self.data = Output.CaptureAnimal(self._io, self, self._root) elif _on == 189: self.data = Output.ResetAiResistTauntLevel(self._io, self, self._root) elif _on == 41: self.data = Output.GetHpHealedToGlobalValue(self._io, self, self._root) elif _on == 215: self.data = Output.FixedMonsterRushMove(self._io, self, self._root) elif _on == 72: self.data = Output.ActCameraShake(self._io, self, self._root) elif _on == 71: self.data = Output.SetAiParam(self._io, self, self._root) elif _on == 168: self.data = Output.ShowScreenEffect(self._io, self, self._root) elif _on == 282: self.data = Output.GetInteractIdToGlobalValue(self._io, self, self._root) elif _on == 171: self.data = Output.ModifyAvatarSkillCd(self._io, self, self._root) elif _on == 36: self.data = Output.SetGlobalValue(self._io, self, self._root) elif _on == 70: self.data = Output.RemoveModifierByAbilityStateResistanceId(self._io, self, self._root) elif _on == 28: self.data = Output.SetCameraLockTime(self._io, self, self._root) elif _on == 193: self.data = Output.SetAvatarHitBuckets(self._io, self, self._root) elif _on == 212: self.data = Output.ShowProgressBarAction(self._io, self, self._root) elif _on == 291: self.data = Output.RefreshRainOccluder(self._io, self, self._root) elif _on == 133: self.data = Output.SetPartControlTarget(self._io, self, self._root) elif _on == 129: self.data = Output.Summon(self._io, self, self._root) elif _on == 74: self.data = Output.SetAnimatorBool(self._io, self, self._root) elif _on == 151: self.data = Output.PaimonAction(self._io, self, self._root) elif _on == 157: self.data = Output.PushDvalinS01process(self._io, self, self._root) elif _on == 16: self.data = Output.AvatarExitFocus(self._io, self, self._root) elif _on == 213: self.data = Output.ChangeTag(self._io, self, self._root) elif _on == 147: self.data = Output.AttachBulletAimPoint(self._io, self, self._root) elif _on == 134: self.data = Output.DropSubfield(self._io, self, self._root) elif _on == 18: self.data = Output.AvatarExitViewBias(self._io, self, self._root) elif _on == 80: self.data = Output.DebugLog(self._io, self, self._root) elif _on == 102: self.data = Output.ClearLockTarget(self._io, self, self._root) elif _on == 68: self.data = Output.ApplyCrystalModifier(self._io, self, self._root) elif _on == 110: self.data = Output.TryFindBlinkPointByBorn(self._io, self, self._root) elif _on == 26: self.data = Output.TurnDirection(self._io, self, self._root) elif _on == 139: self.data = Output.SetAiSkillCdAvailableNow(self._io, self, self._root) elif _on == 155: self.data = Output.ForceAirStateFly(self._io, self, self._root) elif _on == 31: self.data = Output.FireAfterImage(self._io, self, self._root) elif _on == 49: self.data = Output.ClearGlobalValue(self._io, self, self._root) elif _on == 2: self.data = Output.BaseUtilityAction(self._io, self, self._root) elif _on == 135: self.data = Output.EnableGadgetIntee(self._io, self, self._root) elif _on == 124: self.data = Output.SetSelfAttackTarget(self._io, self, self._root) elif _on == 34: self.data = Output.AttachLight(self._io, self, self._root) elif _on == 255: self.data = Output.SetSpecialCamera(self._io, self, self._root) elif _on == 277: self.data = Output.ChangeUgcRayTag(self._io, self, self._root) elif _on == 200: self.data = Output.BroadcastNeuronStimulate(self._io, self, self._root) elif _on == 54: self.data = Output.SetGlobalDir(self._io, self, self._root) elif _on == 29: self.data = Output.FireMonsterBeingHitAfterImage(self._io, self, self._root) elif _on == 132: self.data = Output.AddElementDurability(self._io, self, self._root) elif _on == 270: self.data = Output.GetFightProperty(self._io, self, self._root) elif _on == 175: self.data = Output.EnableAvatarFlyStateTrail(self._io, self, self._root) elif _on == 75: self.data = Output.SetAnimatorInt(self._io, self, self._root) elif _on == 92: self.data = Output.TriggerCreateGadgetToEquipPart(self._io, self, self._root) elif _on == 250: self.data = Output.SetChargeBarValue(self._io, self, self._root) elif _on == 198: self.data = Output.SetNeuronEnable(self._io, self, self._root) elif _on == 111: self.data = Output.TryFindMotionChangePosByBorn(self._io, self, self._root) elif _on == 223: self.data = Output.EnableMonsterMoveOnWater(self._io, self, self._root) elif _on == 190: self.data = Output.ChangeColliderSurface(self._io, self, self._root) elif _on == 247: self.data = Output.ReviveStamina(self._io, self, self._root) elif _on == 25: self.data = Output.SpawnAttach(self._io, self, self._root) elif _on == 43: self.data = Output.SetGlobalValueToOverrideMap(self._io, self, self._root) elif _on == 228: self.data = Output.ShowExtraAbility(self._io, self, self._root) elif _on == 265: self.data = Output.ChangeShieldValue(self._io, self, self._root) elif _on == 196: self.data = Output.RegisterAiActionPoint(self._io, self, self._root) elif _on == 50: self.data = Output.SumTargetWeightToSelfGlobalValue(self._io, self, self._root) elif _on == 22: self.data = Output.AvatarExitCameraShot(self._io, self, self._root) elif _on == 297: self.data = Output.ReviveDeadAvatar(self._io, self, self._root) elif _on == 30: self.data = Output.FireAvatarBeingHitAfterImage(self._io, self, self._root) elif _on == 261: self.data = Output.IgnoreMoveColToRockCol(self._io, self, self._root) elif _on == 278: self.data = Output.SetRegionalPlayVarValue(self._io, self, self._root) elif _on == 272: self.data = Output.GetTeamTotalMaxEnergyToOverridemap(self._io, self, self._root) elif _on == 183: self.data = Output.ChangePlayMode(self._io, self, self._root) elif _on == 173: self.data = Output.ModifyVehicleSkillCd(self._io, self, self._root) elif _on == 128: self.data = Output.StartDither(self._io, self, self._root) elif _on == 90: self.data = Output.TriggerDropEquipParts(self._io, self, self._root) elif _on == 222: self.data = Output.FireGainCrystalSeedEvent(self._io, self, self._root) elif _on == 298: self.data = Output.CreateMovingPlatform(self._io, self, self._root) elif _on == 254: self.data = Output.EnableGadgetSpecialCamera(self._io, self, self._root) elif _on == 154: self.data = Output.SetKeepInAirVelocityForce(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ConfigEmotionTemplateAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_emo_template_id: self.emo_template_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_emo_template_id(self): if hasattr(self, '_m_has_field_emo_template_id'): return self._m_has_field_emo_template_id self._m_has_field_emo_template_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_emo_template_id', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ByEntityIsAlive(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class ConfigMusicSingleGreaterThanCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicSingleCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class ConfigGuideFoundationBuildCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_num: self.num = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_opt: self.opt = Output.EnumGuideOperator(self._io, self, self._root) if self.has_field_is_build: self.is_build = self._io.read_u1() @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) @property def has_field_num(self): if hasattr(self, '_m_has_field_num'): return self._m_has_field_num self._m_has_field_num = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_num', None) @property def has_field_opt(self): if hasattr(self, '_m_has_field_opt'): return self._m_has_field_opt self._m_has_field_opt = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_opt', None) @property def has_field_is_build(self): if hasattr(self, '_m_has_field_is_build'): return self._m_has_field_is_build self._m_has_field_is_build = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_build', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) class MonsterDescribeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigGadgetCreationLimitLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetCreationLimit(self._io, self, self._root)) class SetDvalinS01flyState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_to_state: self.to_state = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_to_state(self): if hasattr(self, '_m_has_field_to_state'): return self._m_has_field_to_state self._m_has_field_to_state = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_to_state', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigRecordEmoParameters(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_eye_info: self.eye_info = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_emo_funcs: self.emo_funcs = Output.ArrayOfConfigRecordEmoFuncLengthU(self._io, self, self._root) @property def has_field_eye_info(self): if hasattr(self, '_m_has_field_eye_info'): return self._m_has_field_eye_info self._m_has_field_eye_info = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_eye_info', None) @property def has_field_emo_funcs(self): if hasattr(self, '_m_has_field_emo_funcs'): return self._m_has_field_emo_funcs self._m_has_field_emo_funcs = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_emo_funcs', None) class ActivityCrystalLinkCondBuffExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGuideCanGetPersonalLineKeyCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = self._io.read_u1() @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def general_condition_type(self): if hasattr(self, '_m_general_condition_type'): return self._m_general_condition_type self._m_general_condition_type = self.base.general_condition_type return getattr(self, '_m_general_condition_type', None) @property def general_condition_val(self): if hasattr(self, '_m_general_condition_val'): return self._m_general_condition_val self._m_general_condition_val = self.base.general_condition_val return getattr(self, '_m_general_condition_val', None) class ModifierTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ContextActionSetIcon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ui_element: self.ui_element = Output.EnumActivityBannerUiElementType(self._io, self, self._root) if self.has_field_icon_alias_name: self.icon_alias_name = AuxTypes.String(self._io, self, self._root) if self.has_field_icon_full_path: self.icon_full_path = AuxTypes.String(self._io, self, self._root) @property def has_field_ui_element(self): if hasattr(self, '_m_has_field_ui_element'): return self._m_has_field_ui_element self._m_has_field_ui_element = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_element', None) @property def has_field_icon_alias_name(self): if hasattr(self, '_m_has_field_icon_alias_name'): return self._m_has_field_icon_alias_name self._m_has_field_icon_alias_name = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_icon_alias_name', None) @property def has_field_icon_full_path(self): if hasattr(self, '_m_has_field_icon_full_path'): return self._m_has_field_icon_full_path self._m_has_field_icon_full_path = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_icon_full_path', None) class ConfigVideoPlayAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_video_name: self.video_name = AuxTypes.String(self._io, self, self._root) if self.has_field_subtitle_id: self.subtitle_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_can_skip: self.can_skip = self._io.read_u1() if self.has_field_bg_color: self.bg_color = Output.ColorVector(self._io, self, self._root) if self.has_field_fade_in_time: self.fade_in_time = self._io.read_f4le() if self.has_field_fade_out_time: self.fade_out_time = self._io.read_f4le() @property def has_field_bg_color(self): if hasattr(self, '_m_has_field_bg_color'): return self._m_has_field_bg_color self._m_has_field_bg_color = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_bg_color', None) @property def has_field_fade_out_time(self): if hasattr(self, '_m_has_field_fade_out_time'): return self._m_has_field_fade_out_time self._m_has_field_fade_out_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_fade_out_time', None) @property def has_field_can_skip(self): if hasattr(self, '_m_has_field_can_skip'): return self._m_has_field_can_skip self._m_has_field_can_skip = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_can_skip', None) @property def has_field_subtitle_id(self): if hasattr(self, '_m_has_field_subtitle_id'): return self._m_has_field_subtitle_id self._m_has_field_subtitle_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_subtitle_id', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_fade_in_time(self): if hasattr(self, '_m_has_field_fade_in_time'): return self._m_has_field_fade_in_time self._m_has_field_fade_in_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_fade_in_time', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) @property def has_field_video_name(self): if hasattr(self, '_m_has_field_video_name'): return self._m_has_field_video_name self._m_has_field_video_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_video_name', None) class DungeonWayPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigScenePoint(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) if self.has_field_is_boss: self.is_boss = self._io.read_u1() if self.has_field_is_active: self.is_active = self._io.read_u1() if self.has_field_group_ids: self.group_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def area_id(self): if hasattr(self, '_m_area_id'): return self._m_area_id self._m_area_id = self.base.area_id return getattr(self, '_m_area_id', None) @property def pos(self): if hasattr(self, '_m_pos'): return self._m_pos self._m_pos = self.base.pos return getattr(self, '_m_pos', None) @property def gadget_id(self): if hasattr(self, '_m_gadget_id'): return self._m_gadget_id self._m_gadget_id = self.base.gadget_id return getattr(self, '_m_gadget_id', None) @property def tran_rot(self): if hasattr(self, '_m_tran_rot'): return self._m_tran_rot self._m_tran_rot = self.base.tran_rot return getattr(self, '_m_tran_rot', None) @property def tran_pos(self): if hasattr(self, '_m_tran_pos'): return self._m_tran_pos self._m_tran_pos = self.base.tran_pos return getattr(self, '_m_tran_pos', None) @property def unlocked(self): if hasattr(self, '_m_unlocked'): return self._m_unlocked self._m_unlocked = self.base.unlocked return getattr(self, '_m_unlocked', None) @property def has_field_is_active(self): if hasattr(self, '_m_has_field_is_active'): return self._m_has_field_is_active self._m_has_field_is_active = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_active', None) @property def alias(self): if hasattr(self, '_m_alias'): return self._m_alias self._m_alias = self.base.alias return getattr(self, '_m_alias', None) @property def rot(self): if hasattr(self, '_m_rot'): return self._m_rot self._m_rot = self.base.rot return getattr(self, '_m_rot', None) @property def has_field_is_boss(self): if hasattr(self, '_m_has_field_is_boss'): return self._m_has_field_is_boss self._m_has_field_is_boss = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_boss', None) @property def is_model_hidden(self): if hasattr(self, '_m_is_model_hidden'): return self._m_is_model_hidden self._m_is_model_hidden = self.base.is_model_hidden return getattr(self, '_m_is_model_hidden', None) @property def group_limit(self): if hasattr(self, '_m_group_limit'): return self._m_group_limit self._m_group_limit = self.base.group_limit return getattr(self, '_m_group_limit', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_size', None) @property def has_field_group_ids(self): if hasattr(self, '_m_has_field_group_ids'): return self._m_has_field_group_ids self._m_has_field_group_ids = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_group_ids', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) class MpPlayWatcherConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumPerfCostRatioGradeF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumPerfCostRatioGradeF4(self._io, self, self._root)) class EnumRoutineCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoutineCondType, self.data.value) return getattr(self, '_m_value', None) class LampRegionDataConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TdPlayMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tower_type: self.tower_type = Output.EnumTdPlayTowerType(self._io, self, self._root) if self.has_field_base_cd: self.base_cd = self._io.read_f4le() if self.has_field_base_attack_range: self.base_attack_range = self._io.read_f4le() if self.has_field_on_fire_actions: self.on_fire_actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) if self.has_field_tower_modifier_name: self.tower_modifier_name = AuxTypes.String(self._io, self, self._root) if self.has_field_bullet_i_ds: self.bullet_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_part_root_names: self.part_root_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumControlPartTargetType(self._io, self, self._root) @property def has_field_tower_modifier_name(self): if hasattr(self, '_m_has_field_tower_modifier_name'): return self._m_has_field_tower_modifier_name self._m_has_field_tower_modifier_name = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_tower_modifier_name', None) @property def has_field_on_fire_actions(self): if hasattr(self, '_m_has_field_on_fire_actions'): return self._m_has_field_on_fire_actions self._m_has_field_on_fire_actions = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_on_fire_actions', None) @property def has_field_base_attack_range(self): if hasattr(self, '_m_has_field_base_attack_range'): return self._m_has_field_base_attack_range self._m_has_field_base_attack_range = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_base_attack_range', None) @property def has_field_base_cd(self): if hasattr(self, '_m_has_field_base_cd'): return self._m_has_field_base_cd self._m_has_field_base_cd = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_base_cd', None) @property def has_field_bullet_i_ds(self): if hasattr(self, '_m_has_field_bullet_i_ds'): return self._m_has_field_bullet_i_ds self._m_has_field_bullet_i_ds = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_bullet_i_ds', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_target_type', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_born', None) @property def has_field_part_root_names(self): if hasattr(self, '_m_has_field_part_root_names'): return self._m_has_field_part_root_names self._m_has_field_part_root_names = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_part_root_names', None) @property def has_field_tower_type(self): if hasattr(self, '_m_has_field_tower_type'): return self._m_has_field_tower_type self._m_has_field_tower_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_tower_type', None) class ShopmallEntranceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sub_tab_list: self.sub_tab_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumShopmallEntranceType(self._io, self, self._root) if self.has_field_order: self.order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_sub_tab_list(self): if hasattr(self, '_m_has_field_sub_tab_list'): return self._m_has_field_sub_tab_list self._m_has_field_sub_tab_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sub_tab_list', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_show_type', None) @property def has_field_order(self): if hasattr(self, '_m_has_field_order'): return self._m_has_field_order self._m_has_field_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_order', None) class ConfigAiSpacialWanderData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_turning_states: self.turning_states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_cd_max: self.cd_max = self._io.read_f4le() if self.has_field_cd_min: self.cd_min = self._io.read_f4le() if self.has_field_terrain_offset_min: self.terrain_offset_min = self._io.read_f4le() if self.has_field_terrain_offset_max: self.terrain_offset_max = self._io.read_f4le() if self.has_field_distance_from_born: self.distance_from_born = self._io.read_f4le() if self.has_field_distance_from_current_min: self.distance_from_current_min = self._io.read_f4le() if self.has_field_distance_from_current_max: self.distance_from_current_max = self._io.read_f4le() if self.has_field_distance_from_edge: self.distance_from_edge = self._io.read_f4le() if self.has_field_cone_angle_threshold: self.cone_angle_threshold = self._io.read_f4le() if self.has_field_cone_weight: self.cone_weight = Output.ConfigAiSpacialWanderConeWeightData(self._io, self, self._root) @property def has_field_cd_max(self): if hasattr(self, '_m_has_field_cd_max'): return self._m_has_field_cd_max self._m_has_field_cd_max = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_cd_max', None) @property def has_field_distance_from_current_min(self): if hasattr(self, '_m_has_field_distance_from_current_min'): return self._m_has_field_distance_from_current_min self._m_has_field_distance_from_current_min = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_distance_from_current_min', None) @property def has_field_terrain_offset_min(self): if hasattr(self, '_m_has_field_terrain_offset_min'): return self._m_has_field_terrain_offset_min self._m_has_field_terrain_offset_min = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_terrain_offset_min', None) @property def has_field_distance_from_born(self): if hasattr(self, '_m_has_field_distance_from_born'): return self._m_has_field_distance_from_born self._m_has_field_distance_from_born = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_distance_from_born', None) @property def has_field_turning_states(self): if hasattr(self, '_m_has_field_turning_states'): return self._m_has_field_turning_states self._m_has_field_turning_states = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_turning_states', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_distance_from_current_max(self): if hasattr(self, '_m_has_field_distance_from_current_max'): return self._m_has_field_distance_from_current_max self._m_has_field_distance_from_current_max = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_distance_from_current_max', None) @property def has_field_cone_angle_threshold(self): if hasattr(self, '_m_has_field_cone_angle_threshold'): return self._m_has_field_cone_angle_threshold self._m_has_field_cone_angle_threshold = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_cone_angle_threshold', None) @property def has_field_cd_min(self): if hasattr(self, '_m_has_field_cd_min'): return self._m_has_field_cd_min self._m_has_field_cd_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_cd_min', None) @property def has_field_cone_weight(self): if hasattr(self, '_m_has_field_cone_weight'): return self._m_has_field_cone_weight self._m_has_field_cone_weight = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_cone_weight', None) @property def has_field_distance_from_edge(self): if hasattr(self, '_m_has_field_distance_from_edge'): return self._m_has_field_distance_from_edge self._m_has_field_distance_from_edge = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_distance_from_edge', None) @property def has_field_terrain_offset_max(self): if hasattr(self, '_m_has_field_terrain_offset_max'): return self._m_has_field_terrain_offset_max self._m_has_field_terrain_offset_max = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_terrain_offset_max', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class WidgetCameraScanExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCrowdSpawnInfos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_crowd_spawn_infos: self.crowd_spawn_infos = Output.ArrayOfConfigCrowdSpawnInfoLengthU(self._io, self, self._root) if self.has_field_crowd_group_collider_infos: self.crowd_group_collider_infos = Output.ArrayOfConfigCrowdGroupColliderInfoLengthU(self._io, self, self._root) @property def has_field_crowd_spawn_infos(self): if hasattr(self, '_m_has_field_crowd_spawn_infos'): return self._m_has_field_crowd_spawn_infos self._m_has_field_crowd_spawn_infos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_crowd_spawn_infos', None) @property def has_field_crowd_group_collider_infos(self): if hasattr(self, '_m_has_field_crowd_group_collider_infos'): return self._m_has_field_crowd_group_collider_infos self._m_has_field_crowd_group_collider_infos = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_crowd_group_collider_infos', None) class GuideNavigationCheckTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RemoveModifierByAbilityStateResistanceId(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_resistance_list_id: self.resistance_list_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_resistance_list_id(self): if hasattr(self, '_m_has_field_resistance_list_id'): return self._m_has_field_resistance_list_id self._m_has_field_resistance_list_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_resistance_list_id', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfSoloConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SoloConfig(self._io, self, self._root)) class LanV2projectionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_sensitivity_free_rotation: self.sensitivity_free_rotation = self._io.read_f4le() if self.has_field_sensitivity_single_axis_rotation: self.sensitivity_single_axis_rotation = self._io.read_f4le() if self.has_field_sensitivity_single_axis_translation: self.sensitivity_single_axis_translation = self._io.read_f4le() if self.has_field_sensitivity_free_rotation_joypad: self.sensitivity_free_rotation_joypad = self._io.read_f4le() if self.has_field_sensitivity_single_axis_rotation_joypad: self.sensitivity_single_axis_rotation_joypad = self._io.read_f4le() if self.has_field_sensitivity_single_axis_translation_joypad: self.sensitivity_single_axis_translation_joypad = self._io.read_f4le() if self.has_field_push_tips_id_joypad: self.push_tips_id_joypad = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id_touch: self.push_tips_id_touch = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_push_tips_id_mouse: self.push_tips_id_mouse = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_threshold_unlock_answer: self.time_threshold_unlock_answer = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_threshold_show_standby_prompt: self.time_threshold_show_standby_prompt = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_time_threshold_show_continuous_progress: self.time_threshold_show_continuous_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lead_guides: self.lead_guides = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_guides: self.guides = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_guide_quest_id: self.guide_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sensitivity_single_axis_translation(self): if hasattr(self, '_m_has_field_sensitivity_single_axis_translation'): return self._m_has_field_sensitivity_single_axis_translation self._m_has_field_sensitivity_single_axis_translation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_sensitivity_single_axis_translation', None) @property def has_field_sensitivity_free_rotation_joypad(self): if hasattr(self, '_m_has_field_sensitivity_free_rotation_joypad'): return self._m_has_field_sensitivity_free_rotation_joypad self._m_has_field_sensitivity_free_rotation_joypad = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_sensitivity_free_rotation_joypad', None) @property def has_field_time_threshold_show_standby_prompt(self): if hasattr(self, '_m_has_field_time_threshold_show_standby_prompt'): return self._m_has_field_time_threshold_show_standby_prompt self._m_has_field_time_threshold_show_standby_prompt = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_time_threshold_show_standby_prompt', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_sensitivity_single_axis_rotation_joypad(self): if hasattr(self, '_m_has_field_sensitivity_single_axis_rotation_joypad'): return self._m_has_field_sensitivity_single_axis_rotation_joypad self._m_has_field_sensitivity_single_axis_rotation_joypad = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_sensitivity_single_axis_rotation_joypad', None) @property def has_field_sensitivity_single_axis_translation_joypad(self): if hasattr(self, '_m_has_field_sensitivity_single_axis_translation_joypad'): return self._m_has_field_sensitivity_single_axis_translation_joypad self._m_has_field_sensitivity_single_axis_translation_joypad = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_sensitivity_single_axis_translation_joypad', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_push_tips_id_touch(self): if hasattr(self, '_m_has_field_push_tips_id_touch'): return self._m_has_field_push_tips_id_touch self._m_has_field_push_tips_id_touch = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_push_tips_id_touch', None) @property def has_field_sensitivity_free_rotation(self): if hasattr(self, '_m_has_field_sensitivity_free_rotation'): return self._m_has_field_sensitivity_free_rotation self._m_has_field_sensitivity_free_rotation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_sensitivity_free_rotation', None) @property def has_field_guides(self): if hasattr(self, '_m_has_field_guides'): return self._m_has_field_guides self._m_has_field_guides = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_guides', None) @property def has_field_push_tips_id_mouse(self): if hasattr(self, '_m_has_field_push_tips_id_mouse'): return self._m_has_field_push_tips_id_mouse self._m_has_field_push_tips_id_mouse = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_push_tips_id_mouse', None) @property def has_field_push_tips_id_joypad(self): if hasattr(self, '_m_has_field_push_tips_id_joypad'): return self._m_has_field_push_tips_id_joypad self._m_has_field_push_tips_id_joypad = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_push_tips_id_joypad', None) @property def has_field_sensitivity_single_axis_rotation(self): if hasattr(self, '_m_has_field_sensitivity_single_axis_rotation'): return self._m_has_field_sensitivity_single_axis_rotation self._m_has_field_sensitivity_single_axis_rotation = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sensitivity_single_axis_rotation', None) @property def has_field_guide_quest_id(self): if hasattr(self, '_m_has_field_guide_quest_id'): return self._m_has_field_guide_quest_id self._m_has_field_guide_quest_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_guide_quest_id', None) @property def has_field_time_threshold_unlock_answer(self): if hasattr(self, '_m_has_field_time_threshold_unlock_answer'): return self._m_has_field_time_threshold_unlock_answer self._m_has_field_time_threshold_unlock_answer = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_time_threshold_unlock_answer', None) @property def has_field_lead_guides(self): if hasattr(self, '_m_has_field_lead_guides'): return self._m_has_field_lead_guides self._m_has_field_lead_guides = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_lead_guides', None) @property def has_field_time_threshold_show_continuous_progress(self): if hasattr(self, '_m_has_field_time_threshold_show_continuous_progress'): return self._m_has_field_time_threshold_show_continuous_progress self._m_has_field_time_threshold_show_continuous_progress = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_time_threshold_show_continuous_progress', None) class ConfigMusicStringEqualityCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicStringCondition(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = self.base.value return getattr(self, '_m_value', None) @property def game_param(self): if hasattr(self, '_m_game_param'): return self._m_game_param self._m_game_param = self.base.game_param return getattr(self, '_m_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class EnumQteStepButtonInputType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QteStepButtonInputType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root)) class SendEffectTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_parameter: self.parameter = AuxTypes.String(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumAnimatorParamType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_float_value: self.float_value = self._io.read_f4le() if self.has_field_not_invoke_when_not_alive: self.not_invoke_when_not_alive = self._io.read_u1() @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_parameter', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_float_value(self): if hasattr(self, '_m_has_field_float_value'): return self._m_has_field_float_value self._m_has_field_float_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_float_value', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_type', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_not_invoke_when_not_alive(self): if hasattr(self, '_m_has_field_not_invoke_when_not_alive'): return self._m_has_field_not_invoke_when_not_alive self._m_has_field_not_invoke_when_not_alive = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_not_invoke_when_not_alive', None) class BoxClampWindZoneMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_attrac_force_strength: self.attrac_force_strength = self._io.read_f4le() if self.has_field_max_strength_range: self.max_strength_range = self._io.read_f4le() @property def has_field_max_strength_range(self): if hasattr(self, '_m_has_field_max_strength_range'): return self._m_has_field_max_strength_range self._m_has_field_max_strength_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_strength_range', None) @property def has_field_attrac_force_strength(self): if hasattr(self, '_m_has_field_attrac_force_strength'): return self._m_has_field_attrac_force_strength self._m_has_field_attrac_force_strength = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_attrac_force_strength', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_size', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class QuestCondUtils(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SteerAttackTraceToPosMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.SteerAttackMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_pos_key: self.global_pos_key = AuxTypes.String(self._io, self, self._root) @property def start_normalized_time(self): if hasattr(self, '_m_start_normalized_time'): return self._m_start_normalized_time self._m_start_normalized_time = self.base.start_normalized_time return getattr(self, '_m_start_normalized_time', None) @property def steer_state_i_ds(self): if hasattr(self, '_m_steer_state_i_ds'): return self._m_steer_state_i_ds self._m_steer_state_i_ds = self.base.steer_state_i_ds return getattr(self, '_m_steer_state_i_ds', None) @property def attack_distance(self): if hasattr(self, '_m_attack_distance'): return self._m_attack_distance self._m_attack_distance = self.base.attack_distance return getattr(self, '_m_attack_distance', None) @property def attack_trigger(self): if hasattr(self, '_m_attack_trigger'): return self._m_attack_trigger self._m_attack_trigger = self.base.attack_trigger return getattr(self, '_m_attack_trigger', None) @property def attack_angle(self): if hasattr(self, '_m_attack_angle'): return self._m_attack_angle self._m_attack_angle = self.base.attack_angle return getattr(self, '_m_attack_angle', None) @property def end_normalized_time(self): if hasattr(self, '_m_end_normalized_time'): return self._m_end_normalized_time self._m_end_normalized_time = self.base.end_normalized_time return getattr(self, '_m_end_normalized_time', None) @property def remote_steer_to_local_target(self): if hasattr(self, '_m_remote_steer_to_local_target'): return self._m_remote_steer_to_local_target self._m_remote_steer_to_local_target = self.base.remote_steer_to_local_target return getattr(self, '_m_remote_steer_to_local_target', None) @property def has_field_global_pos_key(self): if hasattr(self, '_m_has_field_global_pos_key'): return self._m_has_field_global_pos_key self._m_has_field_global_pos_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_pos_key', None) @property def facing_target_types(self): if hasattr(self, '_m_facing_target_types'): return self._m_facing_target_types self._m_facing_target_types = self.base.facing_target_types return getattr(self, '_m_facing_target_types', None) @property def angular_speed(self): if hasattr(self, '_m_angular_speed'): return self._m_angular_speed self._m_angular_speed = self.base.angular_speed return getattr(self, '_m_angular_speed', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class DictOfAuxTypesStringConfigPerfCombineItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfCombineItemOptionArrayInfo(self._io, self, self._root)) class ConfigQteStepCutsceneJumpPointAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_point_id', None) @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) class KvpOfDictAuxTypesVlqBase128LeSAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class ConfigDialogInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dialog_type: self.dialog_type = Output.EnumDialogType(self._io, self, self._root) if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_protect_time: self.protect_time = self._io.read_f4le() if self.has_field_play_audio: self.play_audio = self._io.read_u1() if self.has_field_auto_talk_use_new_protect_time: self.auto_talk_use_new_protect_time = self._io.read_u1() if self.has_field_auto_talk_protect_time: self.auto_talk_protect_time = self._io.read_f4le() @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_protect_time(self): if hasattr(self, '_m_has_field_protect_time'): return self._m_has_field_protect_time self._m_has_field_protect_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_protect_time', None) @property def has_field_dialog_type(self): if hasattr(self, '_m_has_field_dialog_type'): return self._m_has_field_dialog_type self._m_has_field_dialog_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dialog_type', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def has_field_auto_talk_protect_time(self): if hasattr(self, '_m_has_field_auto_talk_protect_time'): return self._m_has_field_auto_talk_protect_time self._m_has_field_auto_talk_protect_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_auto_talk_protect_time', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_play_audio(self): if hasattr(self, '_m_has_field_play_audio'): return self._m_has_field_play_audio self._m_has_field_play_audio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_play_audio', None) @property def has_field_auto_talk_use_new_protect_time(self): if hasattr(self, '_m_has_field_auto_talk_use_new_protect_time'): return self._m_has_field_auto_talk_use_new_protect_time self._m_has_field_auto_talk_use_new_protect_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_auto_talk_use_new_protect_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class HideAndSeekAvatarSdExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumIrodoriMasterMedalType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IrodoriMasterMedalType, self.data.value) return getattr(self, '_m_value', None) class LampRegionDataConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_region: self.region = AuxTypes.String(self._io, self, self._root) if self.has_field_factor: self.factor = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_region(self): if hasattr(self, '_m_has_field_region'): return self._m_has_field_region self._m_has_field_region = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_region', None) @property def has_field_factor(self): if hasattr(self, '_m_has_field_factor'): return self._m_has_field_factor self._m_has_field_factor = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_factor', None) class ByTargetWeight(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_weight: self.weight = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_weight', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class EnumActivityGroupLinkPlayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGroupLinkPlayType, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesVlqBase128LeSConfigAiSpacialChaseData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialChaseData(self._io, self, self._root)) class AvatarPromoteExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_avatar_promote_id: self.avatar_promote_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_promote_level: self.promote_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_promote_audio: self.promote_audio = AuxTypes.String(self._io, self, self._root) if self.has_field_scoin_cost: self.scoin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_unlock_max_level: self.unlock_max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_required_player_level: self.required_player_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_required_player_level(self): if hasattr(self, '_m_has_field_required_player_level'): return self._m_has_field_required_player_level self._m_has_field_required_player_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_required_player_level', None) @property def has_field_scoin_cost(self): if hasattr(self, '_m_has_field_scoin_cost'): return self._m_has_field_scoin_cost self._m_has_field_scoin_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_scoin_cost', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_promote_level(self): if hasattr(self, '_m_has_field_promote_level'): return self._m_has_field_promote_level self._m_has_field_promote_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_promote_level', None) @property def has_field_avatar_promote_id(self): if hasattr(self, '_m_has_field_avatar_promote_id'): return self._m_has_field_avatar_promote_id self._m_has_field_avatar_promote_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_avatar_promote_id', None) @property def has_field_unlock_max_level(self): if hasattr(self, '_m_has_field_unlock_max_level'): return self._m_has_field_unlock_max_level self._m_has_field_unlock_max_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_unlock_max_level', None) @property def has_field_promote_audio(self): if hasattr(self, '_m_has_field_promote_audio'): return self._m_has_field_promote_audio self._m_has_field_promote_audio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_promote_audio', None) class SectrStreamTreeObject(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_color_index: self.color_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_color_index(self): if hasattr(self, '_m_has_field_color_index'): return self._m_has_field_color_index self._m_has_field_color_index = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_color_index', None) class AvatarTalentExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueDiaryResourceExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumRogueDiaryResourceType(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_value', None) class ArrayOfConfigExternalVoiceSoundLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigExternalVoiceSound(self._io, self, self._root)) class KvpOfDictAuxTypesStringConfigLcGadgetIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigLcGadgetIntee(self._io, self, self._root) class OrnamentsTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AttachModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class BlossomChestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chest_gadget_id: self.chest_gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_world_resin: self.world_resin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_resin: self.resin = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_refresh_type: self.refresh_type = Output.EnumBlossomRefreshType(self._io, self, self._root) if self.has_field_client_show_type: self.client_show_type = Output.EnumBlossomChestShowType(self._io, self, self._root) @property def has_field_world_resin(self): if hasattr(self, '_m_has_field_world_resin'): return self._m_has_field_world_resin self._m_has_field_world_resin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_world_resin', None) @property def has_field_chest_gadget_id(self): if hasattr(self, '_m_has_field_chest_gadget_id'): return self._m_has_field_chest_gadget_id self._m_has_field_chest_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_chest_gadget_id', None) @property def has_field_client_show_type(self): if hasattr(self, '_m_has_field_client_show_type'): return self._m_has_field_client_show_type self._m_has_field_client_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_client_show_type', None) @property def has_field_resin(self): if hasattr(self, '_m_has_field_resin'): return self._m_has_field_resin self._m_has_field_resin = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_resin', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_refresh_type(self): if hasattr(self, '_m_has_field_refresh_type'): return self._m_has_field_refresh_type self._m_has_field_refresh_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_refresh_type', None) class MpPlayBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon', None) class EnumNeuronName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.NeuronName, self.data.value) return getattr(self, '_m_value', None) class ConfigSoundBankUnloadPolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_policy: self.policy = Output.EnumSoundBankUnloadPolicy(self._io, self, self._root) if self.has_field_parameter: self.parameter = self._io.read_f4le() @property def has_field_policy(self): if hasattr(self, '_m_has_field_policy'): return self._m_has_field_policy self._m_has_field_policy = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_policy', None) @property def has_field_parameter(self): if hasattr(self, '_m_has_field_parameter'): return self._m_has_field_parameter self._m_has_field_parameter = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_parameter', None) class ConfigPs4trc(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_default_age: self.default_age = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_content_restriction_list: self.content_restriction_list = Output.ArrayOfConfigContentRestrictionLengthU(self._io, self, self._root) @property def has_field_default_age(self): if hasattr(self, '_m_has_field_default_age'): return self._m_has_field_default_age self._m_has_field_default_age = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_age', None) @property def has_field_content_restriction_list(self): if hasattr(self, '_m_has_field_content_restriction_list'): return self._m_has_field_content_restriction_list self._m_has_field_content_restriction_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_content_restriction_list', None) class ConfigVehicleMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) class AnimatorRotationCompensateMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_animator_state_i_ds: self.animator_state_i_ds = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_animation_rotate: self.animation_rotate = self._io.read_f4le() if self.has_field_angle_limit: self.angle_limit = self._io.read_f4le() @property def has_field_animator_state_i_ds(self): if hasattr(self, '_m_has_field_animator_state_i_ds'): return self._m_has_field_animator_state_i_ds self._m_has_field_animator_state_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_animator_state_i_ds', None) @property def has_field_animation_rotate(self): if hasattr(self, '_m_has_field_animation_rotate'): return self._m_has_field_animation_rotate self._m_has_field_animation_rotate = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_animation_rotate', None) @property def has_field_angle_limit(self): if hasattr(self, '_m_has_field_angle_limit'): return self._m_has_field_angle_limit self._m_has_field_angle_limit = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_angle_limit', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfProudSkillOpenConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ProudSkillOpenConfig(self._io, self, self._root)) class ExploreTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GetPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_pos_type: self.pos_type = Output.EnumGetPosType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_pos_type(self): if hasattr(self, '_m_has_field_pos_type'): return self._m_has_field_pos_type self._m_has_field_pos_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_pos_type', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class RandTaskDropConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_drop_id', None) class ConfigRegionalPlayBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_play_type: self.play_type = Output.EnumRegionalPlayType(self._io, self, self._root) if self.has_field_bind_scene: self.bind_scene = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ability_group_name_list: self.ability_group_name_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_is_team: self.is_team = self._io.read_u1() if self.has_field_var_list: self.var_list = Output.ArrayOfConfigRegionalPlayVarDataLengthU(self._io, self, self._root) @property def has_field_is_team(self): if hasattr(self, '_m_has_field_is_team'): return self._m_has_field_is_team self._m_has_field_is_team = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_team', None) @property def has_field_var_list(self): if hasattr(self, '_m_has_field_var_list'): return self._m_has_field_var_list self._m_has_field_var_list = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_var_list', None) @property def has_field_play_type(self): if hasattr(self, '_m_has_field_play_type'): return self._m_has_field_play_type self._m_has_field_play_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_play_type', None) @property def has_field_bind_scene(self): if hasattr(self, '_m_has_field_bind_scene'): return self._m_has_field_bind_scene self._m_has_field_bind_scene = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bind_scene', None) @property def has_field_ability_group_name_list(self): if hasattr(self, '_m_has_field_ability_group_name_list'): return self._m_has_field_ability_group_name_list self._m_has_field_ability_group_name_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_group_name_list', None) class ConfigWidgetAddBuffToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidget(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def is_allowed_in_room(self): if hasattr(self, '_m_is_allowed_in_room'): return self._m_is_allowed_in_room self._m_is_allowed_in_room = self.base.is_allowed_in_room return getattr(self, '_m_is_allowed_in_room', None) @property def is_cd_under_time_scale(self): if hasattr(self, '_m_is_cd_under_time_scale'): return self._m_is_cd_under_time_scale self._m_is_cd_under_time_scale = self.base.is_cd_under_time_scale return getattr(self, '_m_is_cd_under_time_scale', None) @property def is_allowed_in_dungeon(self): if hasattr(self, '_m_is_allowed_in_dungeon'): return self._m_is_allowed_in_dungeon self._m_is_allowed_in_dungeon = self.base.is_allowed_in_dungeon return getattr(self, '_m_is_allowed_in_dungeon', None) @property def cool_down(self): if hasattr(self, '_m_cool_down'): return self._m_cool_down self._m_cool_down = self.base.cool_down return getattr(self, '_m_cool_down', None) @property def ornaments_type(self): if hasattr(self, '_m_ornaments_type'): return self._m_ornaments_type self._m_ornaments_type = self.base.ornaments_type return getattr(self, '_m_ornaments_type', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_buff_id', None) @property def cool_down_group(self): if hasattr(self, '_m_cool_down_group'): return self._m_cool_down_group self._m_cool_down_group = self.base.cool_down_group return getattr(self, '_m_cool_down_group', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def material_id(self): if hasattr(self, '_m_material_id'): return self._m_material_id self._m_material_id = self.base.material_id return getattr(self, '_m_material_id', None) @property def is_equipable(self): if hasattr(self, '_m_is_equipable'): return self._m_is_equipable self._m_is_equipable = self.base.is_equipable return getattr(self, '_m_is_equipable', None) @property def cool_down_on_fail(self): if hasattr(self, '_m_cool_down_on_fail'): return self._m_cool_down_on_fail self._m_cool_down_on_fail = self.base.cool_down_on_fail return getattr(self, '_m_cool_down_on_fail', None) class ConfigLevelNpcBornPosNoGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigLevelNpcBornPos(self._io, self, self._root) @property def scene_id(self): if hasattr(self, '_m_scene_id'): return self._m_scene_id self._m_scene_id = self.base.scene_id return getattr(self, '_m_scene_id', None) @property def born_pos_list(self): if hasattr(self, '_m_born_pos_list'): return self._m_born_pos_list self._m_born_pos_list = self.base.born_pos_list return getattr(self, '_m_born_pos_list', None) class ActivityArenaChallengeExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAudioTreeInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_detect_radius: self.detect_radius = self._io.read_f4le() if self.has_field_data_asset_folder: self.data_asset_folder = AuxTypes.String(self._io, self, self._root) if self.has_field_tree_sound_event_name: self.tree_sound_event_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_tree_num_rtpc_name: self.tree_num_rtpc_name = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_multi_position_type: self.multi_position_type = Output.EnumMultiPositionType(self._io, self, self._root) if self.has_field_data_asset_name_patterns: self.data_asset_name_patterns = Output.ArrayOfAudioTreeDataAssetNamePatternLengthU(self._io, self, self._root) @property def has_field_tree_sound_event_name(self): if hasattr(self, '_m_has_field_tree_sound_event_name'): return self._m_has_field_tree_sound_event_name self._m_has_field_tree_sound_event_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_tree_sound_event_name', None) @property def has_field_detect_radius(self): if hasattr(self, '_m_has_field_detect_radius'): return self._m_has_field_detect_radius self._m_has_field_detect_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_detect_radius', None) @property def has_field_multi_position_type(self): if hasattr(self, '_m_has_field_multi_position_type'): return self._m_has_field_multi_position_type self._m_has_field_multi_position_type = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_multi_position_type', None) @property def has_field_data_asset_name_patterns(self): if hasattr(self, '_m_has_field_data_asset_name_patterns'): return self._m_has_field_data_asset_name_patterns self._m_has_field_data_asset_name_patterns = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_data_asset_name_patterns', None) @property def has_field_tree_num_rtpc_name(self): if hasattr(self, '_m_has_field_tree_num_rtpc_name'): return self._m_has_field_tree_num_rtpc_name self._m_has_field_tree_num_rtpc_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_tree_num_rtpc_name', None) @property def has_field_data_asset_folder(self): if hasattr(self, '_m_has_field_data_asset_folder'): return self._m_has_field_data_asset_folder self._m_has_field_data_asset_folder = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_data_asset_folder', None) class CustomLevelComponentLimitConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_limit_id: self.limit_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_component_id: self.component_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_count: self.max_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_limit_id(self): if hasattr(self, '_m_has_field_limit_id'): return self._m_has_field_limit_id self._m_has_field_limit_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_limit_id', None) @property def has_field_component_id(self): if hasattr(self, '_m_has_field_component_id'): return self._m_has_field_component_id self._m_has_field_component_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_component_id', None) @property def has_field_max_count(self): if hasattr(self, '_m_has_field_max_count'): return self._m_has_field_max_count self._m_has_field_max_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_count', None) class LunaRiteSearchingExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_type: self.region_type = Output.EnumLunaRiteRegionType(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_progress_watcher_id: self.progress_watcher_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id: self.watcher_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_region_center: self.region_center = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_region_name_hash: self.region_name_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_region_name_hash: self.region_name_hash_pre = self._io.read_s1() if self.has_field_region_radius: self.region_radius = self._io.read_f4le() if self.has_field_chest_cond: self.chest_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rune_cond: self.rune_cond = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_chest_mark_num: self.chest_mark_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rune_mark_num: self.rune_mark_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_progress_watcher_id(self): if hasattr(self, '_m_has_field_progress_watcher_id'): return self._m_has_field_progress_watcher_id self._m_has_field_progress_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_progress_watcher_id', None) @property def has_field_region_radius(self): if hasattr(self, '_m_has_field_region_radius'): return self._m_has_field_region_radius self._m_has_field_region_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_region_radius', None) @property def has_field_rune_cond(self): if hasattr(self, '_m_has_field_rune_cond'): return self._m_has_field_rune_cond self._m_has_field_rune_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_rune_cond', None) @property def has_field_chest_cond(self): if hasattr(self, '_m_has_field_chest_cond'): return self._m_has_field_chest_cond self._m_has_field_chest_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_chest_cond', None) @property def has_field_region_center(self): if hasattr(self, '_m_has_field_region_center'): return self._m_has_field_region_center self._m_has_field_region_center = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_region_center', None) @property def has_field_rune_mark_num(self): if hasattr(self, '_m_has_field_rune_mark_num'): return self._m_has_field_rune_mark_num self._m_has_field_rune_mark_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_rune_mark_num', None) @property def has_field_watcher_id(self): if hasattr(self, '_m_has_field_watcher_id'): return self._m_has_field_watcher_id self._m_has_field_watcher_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id', None) @property def has_field_region_type(self): if hasattr(self, '_m_has_field_region_type'): return self._m_has_field_region_type self._m_has_field_region_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_region_type', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_region_name_hash(self): if hasattr(self, '_m_has_field_region_name_hash'): return self._m_has_field_region_name_hash self._m_has_field_region_name_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_region_name_hash', None) @property def has_field_chest_mark_num(self): if hasattr(self, '_m_has_field_chest_mark_num'): return self._m_has_field_chest_mark_num self._m_has_field_chest_mark_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_chest_mark_num', None) class ConfigRuleLimitFrame(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAudioEventCullingRuleBase(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_limit_frame: self.limit_frame = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_limit_frame(self): if hasattr(self, '_m_has_field_limit_frame'): return self._m_has_field_limit_frame self._m_has_field_limit_frame = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_limit_frame', None) class EnumEnvZoneEventType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.EnvZoneEventType, self.data.value) return getattr(self, '_m_value', None) class EnumClimateType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ClimateType, self.data.value) return getattr(self, '_m_value', None) class ConfigMusicParameterCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMusicCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_game_param: self.game_param = Output.EnumMusicGameParam(self._io, self, self._root) @property def has_field_game_param(self): if hasattr(self, '_m_has_field_game_param'): return self._m_has_field_game_param self._m_has_field_game_param = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_game_param', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) class Ps4groupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_icon_path', None) class EnumHuntingMonsterFinishType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HuntingMonsterFinishType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfHomeWorldLimitShopCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.HomeWorldLimitShopCond(self._io, self, self._root)) class ClientSceneTagConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_tag_name: self.scene_tag_name = AuxTypes.String(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_tag_expression: self.scene_tag_expression = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_scene_tag_name(self): if hasattr(self, '_m_has_field_scene_tag_name'): return self._m_has_field_scene_tag_name self._m_has_field_scene_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_tag_name', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_scene_tag_expression(self): if hasattr(self, '_m_has_field_scene_tag_expression'): return self._m_has_field_scene_tag_expression self._m_has_field_scene_tag_expression = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_scene_tag_expression', None) class ProudSkillExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_proud_skill_id: self.proud_skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_proud_skill_group_id: self.proud_skill_group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_proud_skill_type: self.proud_skill_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_desc: self.unlock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_coin_cost: self.coin_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_items: self.cost_items = Output.ArrayOfIdCountConfigLengthS(self._io, self, self._root) if self.has_field_filter_conds: self.filter_conds = Output.ArrayOfEnumTalentFilterCondLengthS(self._io, self, self._root) if self.has_field_break_level: self.break_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param_desc_list: self.param_desc_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_life_effect_type: self.life_effect_type = Output.EnumProudLifeEffectType(self._io, self, self._root) if self.has_field_life_effect_params: self.life_effect_params = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_effective_for_team: self.effective_for_team = self._io.read_s1() if self.has_field_is_hide_life_proud_skill: self.is_hide_life_proud_skill = self._io.read_u1() if self.has_field_open_config: self.open_config = AuxTypes.String(self._io, self, self._root) if self.has_field_add_props: self.add_props = Output.ArrayOfPropValConfigLengthS(self._io, self, self._root) if self.has_field_param_list: self.param_list = Output.ArrayOfF4LengthU(self._io, self, self._root) @property def has_field_life_effect_type(self): if hasattr(self, '_m_has_field_life_effect_type'): return self._m_has_field_life_effect_type self._m_has_field_life_effect_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_life_effect_type', None) @property def has_field_proud_skill_id(self): if hasattr(self, '_m_has_field_proud_skill_id'): return self._m_has_field_proud_skill_id self._m_has_field_proud_skill_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_proud_skill_id', None) @property def has_field_open_config(self): if hasattr(self, '_m_has_field_open_config'): return self._m_has_field_open_config self._m_has_field_open_config = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_open_config', None) @property def has_field_param_desc_list(self): if hasattr(self, '_m_has_field_param_desc_list'): return self._m_has_field_param_desc_list self._m_has_field_param_desc_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_param_desc_list', None) @property def has_field_proud_skill_group_id(self): if hasattr(self, '_m_has_field_proud_skill_group_id'): return self._m_has_field_proud_skill_group_id self._m_has_field_proud_skill_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_proud_skill_group_id', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_filter_conds(self): if hasattr(self, '_m_has_field_filter_conds'): return self._m_has_field_filter_conds self._m_has_field_filter_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_filter_conds', None) @property def has_field_break_level(self): if hasattr(self, '_m_has_field_break_level'): return self._m_has_field_break_level self._m_has_field_break_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_break_level', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_proud_skill_type(self): if hasattr(self, '_m_has_field_proud_skill_type'): return self._m_has_field_proud_skill_type self._m_has_field_proud_skill_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_proud_skill_type', None) @property def has_field_param_list(self): if hasattr(self, '_m_has_field_param_list'): return self._m_has_field_param_list self._m_has_field_param_list = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_param_list', None) @property def has_field_is_hide_life_proud_skill(self): if hasattr(self, '_m_has_field_is_hide_life_proud_skill'): return self._m_has_field_is_hide_life_proud_skill self._m_has_field_is_hide_life_proud_skill = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_is_hide_life_proud_skill', None) @property def has_field_life_effect_params(self): if hasattr(self, '_m_has_field_life_effect_params'): return self._m_has_field_life_effect_params self._m_has_field_life_effect_params = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_life_effect_params', None) @property def has_field_coin_cost(self): if hasattr(self, '_m_has_field_coin_cost'): return self._m_has_field_coin_cost self._m_has_field_coin_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_coin_cost', None) @property def has_field_unlock_desc(self): if hasattr(self, '_m_has_field_unlock_desc'): return self._m_has_field_unlock_desc self._m_has_field_unlock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_unlock_desc', None) @property def has_field_add_props(self): if hasattr(self, '_m_has_field_add_props'): return self._m_has_field_add_props self._m_has_field_add_props = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_add_props', None) @property def has_field_cost_items(self): if hasattr(self, '_m_has_field_cost_items'): return self._m_has_field_cost_items self._m_has_field_cost_items = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cost_items', None) @property def has_field_effective_for_team(self): if hasattr(self, '_m_has_field_effective_for_team'): return self._m_has_field_effective_for_team self._m_has_field_effective_for_team = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_effective_for_team', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_icon', None) class ConfigBulletWane(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_wane_delay: self.wane_delay = self._io.read_f4le() if self.has_field_damage_wane_interval: self.damage_wane_interval = self._io.read_f4le() if self.has_field_damage_wane_ratio: self.damage_wane_ratio = self._io.read_f4le() if self.has_field_damage_wane_min_ratio: self.damage_wane_min_ratio = self._io.read_f4le() if self.has_field_element_durability_wane_interval: self.element_durability_wane_interval = self._io.read_f4le() if self.has_field_element_durability_wane_ratio: self.element_durability_wane_ratio = self._io.read_f4le() if self.has_field_element_durability_wane_min_ratio: self.element_durability_wane_min_ratio = self._io.read_f4le() if self.has_field_hit_level_wane_interval: self.hit_level_wane_interval = self._io.read_f4le() if self.has_field_hit_level_wane_min: self.hit_level_wane_min = Output.EnumHitLevel(self._io, self, self._root) @property def has_field_damage_wane_ratio(self): if hasattr(self, '_m_has_field_damage_wane_ratio'): return self._m_has_field_damage_wane_ratio self._m_has_field_damage_wane_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_damage_wane_ratio', None) @property def has_field_wane_delay(self): if hasattr(self, '_m_has_field_wane_delay'): return self._m_has_field_wane_delay self._m_has_field_wane_delay = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_wane_delay', None) @property def has_field_damage_wane_interval(self): if hasattr(self, '_m_has_field_damage_wane_interval'): return self._m_has_field_damage_wane_interval self._m_has_field_damage_wane_interval = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_damage_wane_interval', None) @property def has_field_element_durability_wane_ratio(self): if hasattr(self, '_m_has_field_element_durability_wane_ratio'): return self._m_has_field_element_durability_wane_ratio self._m_has_field_element_durability_wane_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_element_durability_wane_ratio', None) @property def has_field_damage_wane_min_ratio(self): if hasattr(self, '_m_has_field_damage_wane_min_ratio'): return self._m_has_field_damage_wane_min_ratio self._m_has_field_damage_wane_min_ratio = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_damage_wane_min_ratio', None) @property def has_field_element_durability_wane_min_ratio(self): if hasattr(self, '_m_has_field_element_durability_wane_min_ratio'): return self._m_has_field_element_durability_wane_min_ratio self._m_has_field_element_durability_wane_min_ratio = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_element_durability_wane_min_ratio', None) @property def has_field_hit_level_wane_interval(self): if hasattr(self, '_m_has_field_hit_level_wane_interval'): return self._m_has_field_hit_level_wane_interval self._m_has_field_hit_level_wane_interval = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_hit_level_wane_interval', None) @property def has_field_element_durability_wane_interval(self): if hasattr(self, '_m_has_field_element_durability_wane_interval'): return self._m_has_field_element_durability_wane_interval self._m_has_field_element_durability_wane_interval = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_element_durability_wane_interval', None) @property def has_field_hit_level_wane_min(self): if hasattr(self, '_m_has_field_hit_level_wane_min'): return self._m_has_field_hit_level_wane_min self._m_has_field_hit_level_wane_min = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_hit_level_wane_min', None) class FallbackMarkTipsTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReminderShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfSectrCityLevelTagOffsetInfoLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.SectrCityLevelTagOffsetInfo(self._io, self, self._root)) class EnumReminderStyleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReminderStyleType, self.data.value) return getattr(self, '_m_value', None) class DictOfEnumTextMapPlatformTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumTextMapPlatformTypeAuxTypesVlqBase128LeS(self._io, self, self._root)) class FireworksLaunchExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_launch_param_type: self.launch_param_type = Output.EnumFireworksLaunchParamType(self._io, self, self._root) if self.has_field_default_value: self.default_value = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_adjust_range: self.adjust_range = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_adjust_step: self.adjust_step = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_launch_param_name: self.launch_param_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_adjust_range(self): if hasattr(self, '_m_has_field_adjust_range'): return self._m_has_field_adjust_range self._m_has_field_adjust_range = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_adjust_range', None) @property def has_field_launch_param_name(self): if hasattr(self, '_m_has_field_launch_param_name'): return self._m_has_field_launch_param_name self._m_has_field_launch_param_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_launch_param_name', None) @property def has_field_launch_param_type(self): if hasattr(self, '_m_has_field_launch_param_type'): return self._m_has_field_launch_param_type self._m_has_field_launch_param_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_launch_param_type', None) @property def has_field_default_value(self): if hasattr(self, '_m_has_field_default_value'): return self._m_has_field_default_value self._m_has_field_default_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_default_value', None) @property def has_field_adjust_step(self): if hasattr(self, '_m_has_field_adjust_step'): return self._m_has_field_adjust_step self._m_has_field_adjust_step = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_adjust_step', None) class DoActionByKillingMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_tags: self.attack_tags = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_detect_window: self.detect_window = self._io.read_f4le() if self.has_field_on_kill: self.on_kill = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_attack_tags(self): if hasattr(self, '_m_has_field_attack_tags'): return self._m_has_field_attack_tags self._m_has_field_attack_tags = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_tags', None) @property def has_field_detect_window(self): if hasattr(self, '_m_has_field_detect_window'): return self._m_has_field_detect_window self._m_has_field_detect_window = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_detect_window', None) @property def has_field_on_kill(self): if hasattr(self, '_m_has_field_on_kill'): return self._m_has_field_on_kill self._m_has_field_on_kill = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_on_kill', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigClimateAudio(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_ui_len_stop_audio: self.ui_len_stop_audio = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_len_low_audio: self.ui_len_low_audio = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_len_middle_audio: self.ui_len_middle_audio = AuxTypes.String(self._io, self, self._root) if self.has_field_ui_len_max_audio: self.ui_len_max_audio = AuxTypes.String(self._io, self, self._root) @property def has_field_ui_len_stop_audio(self): if hasattr(self, '_m_has_field_ui_len_stop_audio'): return self._m_has_field_ui_len_stop_audio self._m_has_field_ui_len_stop_audio = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ui_len_stop_audio', None) @property def has_field_ui_len_low_audio(self): if hasattr(self, '_m_has_field_ui_len_low_audio'): return self._m_has_field_ui_len_low_audio self._m_has_field_ui_len_low_audio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_ui_len_low_audio', None) @property def has_field_ui_len_middle_audio(self): if hasattr(self, '_m_has_field_ui_len_middle_audio'): return self._m_has_field_ui_len_middle_audio self._m_has_field_ui_len_middle_audio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ui_len_middle_audio', None) @property def has_field_ui_len_max_audio(self): if hasattr(self, '_m_has_field_ui_len_max_audio'): return self._m_has_field_ui_len_max_audio self._m_has_field_ui_len_max_audio = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_ui_len_max_audio', None) class RoutineDetailExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_routine_id: self.routine_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_routine_type: self.routine_type = Output.EnumGeneralRoutineType(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tag: self.tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_backup: self.is_backup = self._io.read_u1() if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_content: self.finish_content = Output.RoutineFinishContent(self._io, self, self._root) if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_cond_vec: self.cond_vec = Output.ArrayOfRoutineCondContentLengthS(self._io, self, self._root) if self.has_field_action_vec: self.action_vec = Output.ArrayOfRoutineActionContentLengthS(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_goal: self.goal = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_position: self.center_position = AuxTypes.String(self._io, self, self._root) if self.has_field_radar_radius: self.radar_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_enter_distance: self.enter_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exit_distance: self.exit_distance = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_exit_distance(self): if hasattr(self, '_m_has_field_exit_distance'): return self._m_has_field_exit_distance self._m_has_field_exit_distance = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_exit_distance', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_center_position(self): if hasattr(self, '_m_has_field_center_position'): return self._m_has_field_center_position self._m_has_field_center_position = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_center_position', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_radar_radius(self): if hasattr(self, '_m_has_field_radar_radius'): return self._m_has_field_radar_radius self._m_has_field_radar_radius = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_radar_radius', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_is_backup(self): if hasattr(self, '_m_has_field_is_backup'): return self._m_has_field_is_backup self._m_has_field_is_backup = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_backup', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_cond_vec(self): if hasattr(self, '_m_has_field_cond_vec'): return self._m_has_field_cond_vec self._m_has_field_cond_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_cond_vec', None) @property def has_field_routine_id(self): if hasattr(self, '_m_has_field_routine_id'): return self._m_has_field_routine_id self._m_has_field_routine_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_routine_id', None) @property def has_field_goal(self): if hasattr(self, '_m_has_field_goal'): return self._m_has_field_goal self._m_has_field_goal = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_goal', None) @property def has_field_finish_content(self): if hasattr(self, '_m_has_field_finish_content'): return self._m_has_field_finish_content self._m_has_field_finish_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_finish_content', None) @property def has_field_tag(self): if hasattr(self, '_m_has_field_tag'): return self._m_has_field_tag self._m_has_field_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_tag', None) @property def has_field_enter_distance(self): if hasattr(self, '_m_has_field_enter_distance'): return self._m_has_field_enter_distance self._m_has_field_enter_distance = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_enter_distance', None) @property def has_field_routine_type(self): if hasattr(self, '_m_has_field_routine_type'): return self._m_has_field_routine_type self._m_has_field_routine_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_routine_type', None) @property def has_field_action_vec(self): if hasattr(self, '_m_has_field_action_vec'): return self._m_has_field_action_vec self._m_has_field_action_vec = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_action_vec', None) class LunaRiteRegionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PhotographPosenameExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_pose_file: self.pose_file = AuxTypes.String(self._io, self, self._root) if self.has_field_animatorstate_id: self.animatorstate_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pose_icon: self.pose_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_pose_name: self.pose_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_desc: self.unlock_desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) @property def has_field_animatorstate_id(self): if hasattr(self, '_m_has_field_animatorstate_id'): return self._m_has_field_animatorstate_id self._m_has_field_animatorstate_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_animatorstate_id', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_pose_file(self): if hasattr(self, '_m_has_field_pose_file'): return self._m_has_field_pose_file self._m_has_field_pose_file = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_pose_file', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_unlock_desc(self): if hasattr(self, '_m_has_field_unlock_desc'): return self._m_has_field_unlock_desc self._m_has_field_unlock_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_unlock_desc', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_finish_conds', None) @property def has_field_pose_name(self): if hasattr(self, '_m_has_field_pose_name'): return self._m_has_field_pose_name self._m_has_field_pose_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pose_name', None) @property def has_field_pose_icon(self): if hasattr(self, '_m_has_field_pose_icon'): return self._m_has_field_pose_icon self._m_has_field_pose_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_pose_icon', None) class EnumInvestigationType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InvestigationType, self.data.value) return getattr(self, '_m_value', None) class EnumActivityIslandPartyStageType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityIslandPartyStageType, self.data.value) return getattr(self, '_m_value', None) class DoWidgetSystemAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_widget_event: self.widget_event = Output.EnumWidgetEventType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_widget_event(self): if hasattr(self, '_m_has_field_widget_event'): return self._m_has_field_widget_event self._m_has_field_widget_event = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_widget_event', None) class MusicGameBasicConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireworksTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQualityType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QualityType, self.data.value) return getattr(self, '_m_value', None) class HomeWorldShopSubTagExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_sub_id: self.sub_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_new_mark: self.show_new_mark = self._io.read_u1() if self.has_field_sub_tag: self.sub_tag = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_sub_id(self): if hasattr(self, '_m_has_field_sub_id'): return self._m_has_field_sub_id self._m_has_field_sub_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_sub_id', None) @property def has_field_show_new_mark(self): if hasattr(self, '_m_has_field_show_new_mark'): return self._m_has_field_show_new_mark self._m_has_field_show_new_mark = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_show_new_mark', None) @property def has_field_sub_tag(self): if hasattr(self, '_m_has_field_sub_tag'): return self._m_has_field_sub_tag self._m_has_field_sub_tag = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sub_tag', None) class AvatarCurveExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_curve_infos: self.curve_infos = Output.ArrayOfGrowCurveInfoLengthS(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_curve_infos(self): if hasattr(self, '_m_has_field_curve_infos'): return self._m_has_field_curve_infos self._m_has_field_curve_infos = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_curve_infos', None) class LoseHp(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_amount: self.amount = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_caster_max_hp_ratio: self.amount_by_caster_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_target_max_hp_ratio: self.amount_by_target_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_target_current_hp_ratio: self.amount_by_target_current_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_amount_by_caster_attack_ratio: self.amount_by_caster_attack_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_limbo_by_target_max_hp_ratio: self.limbo_by_target_max_hp_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_lethal: self.lethal = self._io.read_u1() if self.has_field_enable_invincible: self.enable_invincible = self._io.read_u1() if self.has_field_enable_lock_hp: self.enable_lock_hp = self._io.read_u1() if self.has_field_disable_when_loading: self.disable_when_loading = self._io.read_u1() if self.has_field_use_meta: self.use_meta = self._io.read_u1() @property def has_field_amount(self): if hasattr(self, '_m_has_field_amount'): return self._m_has_field_amount self._m_has_field_amount = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_amount', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_disable_when_loading(self): if hasattr(self, '_m_has_field_disable_when_loading'): return self._m_has_field_disable_when_loading self._m_has_field_disable_when_loading = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_disable_when_loading', None) @property def has_field_amount_by_target_max_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_target_max_hp_ratio'): return self._m_has_field_amount_by_target_max_hp_ratio self._m_has_field_amount_by_target_max_hp_ratio = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_amount_by_target_max_hp_ratio', None) @property def has_field_enable_invincible(self): if hasattr(self, '_m_has_field_enable_invincible'): return self._m_has_field_enable_invincible self._m_has_field_enable_invincible = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_enable_invincible', None) @property def has_field_enable_lock_hp(self): if hasattr(self, '_m_has_field_enable_lock_hp'): return self._m_has_field_enable_lock_hp self._m_has_field_enable_lock_hp = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enable_lock_hp', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_amount_by_target_current_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_target_current_hp_ratio'): return self._m_has_field_amount_by_target_current_hp_ratio self._m_has_field_amount_by_target_current_hp_ratio = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_amount_by_target_current_hp_ratio', None) @property def has_field_limbo_by_target_max_hp_ratio(self): if hasattr(self, '_m_has_field_limbo_by_target_max_hp_ratio'): return self._m_has_field_limbo_by_target_max_hp_ratio self._m_has_field_limbo_by_target_max_hp_ratio = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_limbo_by_target_max_hp_ratio', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_lethal(self): if hasattr(self, '_m_has_field_lethal'): return self._m_has_field_lethal self._m_has_field_lethal = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_lethal', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_meta(self): if hasattr(self, '_m_has_field_use_meta'): return self._m_has_field_use_meta self._m_has_field_use_meta = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_use_meta', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_amount_by_caster_attack_ratio(self): if hasattr(self, '_m_has_field_amount_by_caster_attack_ratio'): return self._m_has_field_amount_by_caster_attack_ratio self._m_has_field_amount_by_caster_attack_ratio = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_amount_by_caster_attack_ratio', None) @property def has_field_amount_by_caster_max_hp_ratio(self): if hasattr(self, '_m_has_field_amount_by_caster_max_hp_ratio'): return self._m_has_field_amount_by_caster_max_hp_ratio self._m_has_field_amount_by_caster_max_hp_ratio = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_amount_by_caster_max_hp_ratio', None) class DispConfigActionPointSelectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigActionPointSelectType(self._io, self, self._root) elif _on == 4: self.data = Output.SelectActionPointByAwayFromAvatar(self._io, self, self._root) elif _on == 6: self.data = Output.SelectActionPointByAllAvatarsOrientation(self._io, self, self._root) elif _on == 1: self.data = Output.SelectActionPointById(self._io, self, self._root) elif _on == 3: self.data = Output.SelectActionPointByTargetPos(self._io, self, self._root) elif _on == 5: self.data = Output.SelectActionPointByTargetOrientation(self._io, self, self._root) elif _on == 2: self.data = Output.SelectActionPointBySelfPos(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class BattlePassScheduleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GlobalWatcherConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ProductAppleGiftCardDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_content_vec: self.content_vec = Output.ArrayOfPackageContentConfigLengthS(self._io, self, self._root) if self.has_field_mail_config_id: self.mail_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_content_vec(self): if hasattr(self, '_m_has_field_content_vec'): return self._m_has_field_content_vec self._m_has_field_content_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_content_vec', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_mail_config_id(self): if hasattr(self, '_m_has_field_mail_config_id'): return self._m_has_field_mail_config_id self._m_has_field_mail_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mail_config_id', None) class ArrayOfConfigRecoverEnergyEffectLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigRecoverEnergyEffect(self._io, self, self._root)) class MapTagTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumQuestExecType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.QuestExecType, self.data.value) return getattr(self, '_m_value', None) class ConfigBattleFervorUpdatePredicate(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ReliquaryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_equip_type: self.equip_type = Output.EnumEquipType(self._io, self, self._root) if self.has_field_show_pic: self.show_pic = AuxTypes.String(self._io, self, self._root) if self.has_field_rank_level: self.rank_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_main_prop_depot_id: self.main_prop_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_append_prop_depot_id: self.append_prop_depot_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_append_prop_num: self.append_prop_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_set_id: self.set_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_prop_levels: self.add_prop_levels = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_base_conv_exp: self.base_conv_exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_level: self.max_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_story_id: self.story_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_destroy_rule: self.destroy_rule = Output.EnumMaterialDestroyType(self._io, self, self._root) if self.has_field_destroy_return_material: self.destroy_return_material = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_destroy_return_material_count: self.destroy_return_material_count = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_initial_lock_state: self.initial_lock_state = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_item_type: self.item_type = Output.EnumItemType(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rank: self.rank = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dropable: self.dropable = self._io.read_u1() if self.has_field_use_level: self.use_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_global_item_limit: self.global_item_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_base_conv_exp(self): if hasattr(self, '_m_has_field_base_conv_exp'): return self._m_has_field_base_conv_exp self._m_has_field_base_conv_exp = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_base_conv_exp', None) @property def has_field_destroy_rule(self): if hasattr(self, '_m_has_field_destroy_rule'): return self._m_has_field_destroy_rule self._m_has_field_destroy_rule = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_destroy_rule', None) @property def has_field_destroy_return_material(self): if hasattr(self, '_m_has_field_destroy_return_material'): return self._m_has_field_destroy_return_material self._m_has_field_destroy_return_material = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_destroy_return_material', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_story_id(self): if hasattr(self, '_m_has_field_story_id'): return self._m_has_field_story_id self._m_has_field_story_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_story_id', None) @property def has_field_rank(self): if hasattr(self, '_m_has_field_rank'): return self._m_has_field_rank self._m_has_field_rank = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_rank', None) @property def has_field_dropable(self): if hasattr(self, '_m_has_field_dropable'): return self._m_has_field_dropable self._m_has_field_dropable = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_dropable', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_append_prop_depot_id(self): if hasattr(self, '_m_has_field_append_prop_depot_id'): return self._m_has_field_append_prop_depot_id self._m_has_field_append_prop_depot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_append_prop_depot_id', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_use_level(self): if hasattr(self, '_m_has_field_use_level'): return self._m_has_field_use_level self._m_has_field_use_level = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_use_level', None) @property def has_field_equip_type(self): if hasattr(self, '_m_has_field_equip_type'): return self._m_has_field_equip_type self._m_has_field_equip_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_equip_type', None) @property def has_field_max_level(self): if hasattr(self, '_m_has_field_max_level'): return self._m_has_field_max_level self._m_has_field_max_level = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_max_level', None) @property def has_field_initial_lock_state(self): if hasattr(self, '_m_has_field_initial_lock_state'): return self._m_has_field_initial_lock_state self._m_has_field_initial_lock_state = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_initial_lock_state', None) @property def has_field_set_id(self): if hasattr(self, '_m_has_field_set_id'): return self._m_has_field_set_id self._m_has_field_set_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_set_id', None) @property def has_field_append_prop_num(self): if hasattr(self, '_m_has_field_append_prop_num'): return self._m_has_field_append_prop_num self._m_has_field_append_prop_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_append_prop_num', None) @property def has_field_global_item_limit(self): if hasattr(self, '_m_has_field_global_item_limit'): return self._m_has_field_global_item_limit self._m_has_field_global_item_limit = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_global_item_limit', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_rank_level(self): if hasattr(self, '_m_has_field_rank_level'): return self._m_has_field_rank_level self._m_has_field_rank_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_rank_level', None) @property def has_field_add_prop_levels(self): if hasattr(self, '_m_has_field_add_prop_levels'): return self._m_has_field_add_prop_levels self._m_has_field_add_prop_levels = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_add_prop_levels', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_main_prop_depot_id(self): if hasattr(self, '_m_has_field_main_prop_depot_id'): return self._m_has_field_main_prop_depot_id self._m_has_field_main_prop_depot_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_main_prop_depot_id', None) @property def has_field_show_pic(self): if hasattr(self, '_m_has_field_show_pic'): return self._m_has_field_show_pic self._m_has_field_show_pic = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_show_pic', None) @property def has_field_item_type(self): if hasattr(self, '_m_has_field_item_type'): return self._m_has_field_item_type self._m_has_field_item_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_item_type', None) @property def has_field_destroy_return_material_count(self): if hasattr(self, '_m_has_field_destroy_return_material_count'): return self._m_has_field_destroy_return_material_count self._m_has_field_destroy_return_material_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_destroy_return_material_count', None) class RogueDiaryRoomExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_normal_tide_id: self.normal_tide_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_hard_tide_id: self.hard_tide_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_reward_normal: self.coin_reward_normal = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coin_reward_hard: self.coin_reward_hard = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_hard: self.desc_hard = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_boss: self.is_boss = self._io.read_u1() @property def has_field_coin_reward_hard(self): if hasattr(self, '_m_has_field_coin_reward_hard'): return self._m_has_field_coin_reward_hard self._m_has_field_coin_reward_hard = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_coin_reward_hard', None) @property def has_field_is_boss(self): if hasattr(self, '_m_has_field_is_boss'): return self._m_has_field_is_boss self._m_has_field_is_boss = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_boss', None) @property def has_field_normal_tide_id(self): if hasattr(self, '_m_has_field_normal_tide_id'): return self._m_has_field_normal_tide_id self._m_has_field_normal_tide_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_normal_tide_id', None) @property def has_field_desc_hard(self): if hasattr(self, '_m_has_field_desc_hard'): return self._m_has_field_desc_hard self._m_has_field_desc_hard = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc_hard', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_challenge_id', None) @property def has_field_hard_tide_id(self): if hasattr(self, '_m_has_field_hard_tide_id'): return self._m_has_field_hard_tide_id self._m_has_field_hard_tide_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_hard_tide_id', None) @property def has_field_coin_reward_normal(self): if hasattr(self, '_m_has_field_coin_reward_normal'): return self._m_has_field_coin_reward_normal self._m_has_field_coin_reward_normal = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_coin_reward_normal', None) class EnumRealScenePointType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RealScenePointType, self.data.value) return getattr(self, '_m_value', None) class ClimateTrendTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerToStates(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_trigger: self.trigger = AuxTypes.String(self._io, self, self._root) if self.has_field_play_time: self.play_time = self._io.read_f4le() if self.has_field_states: self.states = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_bow_draw_times: self.bow_draw_times = Output.ArrayOfBowDrawTimeLengthU(self._io, self, self._root) if self.has_field_float_id: self.float_id = AuxTypes.String(self._io, self, self._root) if self.has_field_float_value: self.float_value = self._io.read_f4le() @property def has_field_play_time(self): if hasattr(self, '_m_has_field_play_time'): return self._m_has_field_play_time self._m_has_field_play_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_play_time', None) @property def has_field_bow_draw_times(self): if hasattr(self, '_m_has_field_bow_draw_times'): return self._m_has_field_bow_draw_times self._m_has_field_bow_draw_times = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_bow_draw_times', None) @property def has_field_float_value(self): if hasattr(self, '_m_has_field_float_value'): return self._m_has_field_float_value self._m_has_field_float_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_float_value', None) @property def has_field_trigger(self): if hasattr(self, '_m_has_field_trigger'): return self._m_has_field_trigger self._m_has_field_trigger = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger', None) @property def has_field_states(self): if hasattr(self, '_m_has_field_states'): return self._m_has_field_states self._m_has_field_states = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_states', None) @property def has_field_float_id(self): if hasattr(self, '_m_has_field_float_id'): return self._m_has_field_float_id self._m_has_field_float_id = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_float_id', None) class SetGlobalValueByTargetDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_is_xz: self.is_xz = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_is_xz(self): if hasattr(self, '_m_has_field_is_xz'): return self._m_has_field_is_xz self._m_has_field_is_xz = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_is_xz', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ExclusivePlatformTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoguelikeEffectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PerfConfigPlatformComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCreateGadgetMixinType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CreateGadgetMixinType, self.data.value) return getattr(self, '_m_value', None) class IrodoriChessCardTargetTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DisplayItemTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBattleFervorFactorByTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBattleFervorFactor(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_triggers: self.triggers = Output.ArrayOfDispConfigBattleFervorUpdateTriggerLengthU(self._io, self, self._root) @property def has_field_triggers(self): if hasattr(self, '_m_has_field_triggers'): return self._m_has_field_triggers self._m_has_field_triggers = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_triggers', None) @property def factor_min_value(self): if hasattr(self, '_m_factor_min_value'): return self._m_factor_min_value self._m_factor_min_value = self.base.factor_min_value return getattr(self, '_m_factor_min_value', None) @property def factor_max_value(self): if hasattr(self, '_m_factor_max_value'): return self._m_factor_max_value self._m_factor_max_value = self.base.factor_max_value return getattr(self, '_m_factor_max_value', None) @property def factor_init_value(self): if hasattr(self, '_m_factor_init_value'): return self._m_factor_init_value self._m_factor_init_value = self.base.factor_init_value return getattr(self, '_m_factor_init_value', None) class ByAttackNotHitScene(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_pattern: self.attack_pattern = Output.DispConfigBaseAttackPattern(self._io, self, self._root) if self.has_field_check_water_layer: self.check_water_layer = self._io.read_u1() @property def has_field_attack_pattern(self): if hasattr(self, '_m_has_field_attack_pattern'): return self._m_has_field_attack_pattern self._m_has_field_attack_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_pattern', None) @property def has_field_check_water_layer(self): if hasattr(self, '_m_has_field_check_water_layer'): return self._m_has_field_check_water_layer self._m_has_field_check_water_layer = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_check_water_layer', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class WorldTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigCameraSplineBaseTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigCameraSplineBaseTarget(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigCameraSplineCatmullTarget(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigCameraSplineBezierTarget(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DynamicInteractionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_self_content: self.self_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_self_content1: self.self_content1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_self_intee_icon_name: self.self_intee_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_other_content: self.other_content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_other_intee_icon_name: self.other_intee_icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_other_can_intee: self.other_can_intee = self._io.read_u1() @property def has_field_self_intee_icon_name(self): if hasattr(self, '_m_has_field_self_intee_icon_name'): return self._m_has_field_self_intee_icon_name self._m_has_field_self_intee_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_self_intee_icon_name', None) @property def has_field_other_intee_icon_name(self): if hasattr(self, '_m_has_field_other_intee_icon_name'): return self._m_has_field_other_intee_icon_name self._m_has_field_other_intee_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_other_intee_icon_name', None) @property def has_field_other_content(self): if hasattr(self, '_m_has_field_other_content'): return self._m_has_field_other_content self._m_has_field_other_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_other_content', None) @property def has_field_self_content1(self): if hasattr(self, '_m_has_field_self_content1'): return self._m_has_field_self_content1 self._m_has_field_self_content1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_self_content1', None) @property def has_field_self_content(self): if hasattr(self, '_m_has_field_self_content'): return self._m_has_field_self_content self._m_has_field_self_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_self_content', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_other_can_intee(self): if hasattr(self, '_m_has_field_other_can_intee'): return self._m_has_field_other_can_intee self._m_has_field_other_can_intee = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_other_can_intee', None) class BillboardMarkMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_show_distance: self.show_distance = self._io.read_f4le() @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_icon_name', None) @property def has_field_show_distance(self): if hasattr(self, '_m_has_field_show_distance'): return self._m_has_field_show_distance self._m_has_field_show_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_show_distance', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ArrayOfDailyTaskDropConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DailyTaskDropConfig(self._io, self, self._root)) class DropNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_num_interval: self.num_interval = AuxTypes.String(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_num_interval(self): if hasattr(self, '_m_has_field_num_interval'): return self._m_has_field_num_interval self._m_has_field_num_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_num_interval', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_weight', None) class EnumReferenceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ReferenceType, self.data.value) return getattr(self, '_m_value', None) class ConfigLcBaseIntee(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_trigger_shape_in: self.trigger_shape_in = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_shape_in_height: self.trigger_shape_in_height = self._io.read_f4le() if self.has_field_trigger_shape_out: self.trigger_shape_out = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_shape_out_height: self.trigger_shape_out_height = self._io.read_f4le() if self.has_field_trigger_shape_in_offset: self.trigger_shape_in_offset = Output.Vector(self._io, self, self._root) if self.has_field_trigger_shape_out_offset: self.trigger_shape_out_offset = Output.Vector(self._io, self, self._root) if self.has_field_trigger_shape_free_interaction: self.trigger_shape_free_interaction = AuxTypes.String(self._io, self, self._root) if self.has_field_trigger_shape_free_interaction_height: self.trigger_shape_free_interaction_height = self._io.read_f4le() if self.has_field_trigger_shape_free_interaction_offset: self.trigger_shape_free_interaction_offset = Output.Vector(self._io, self, self._root) @property def has_field_trigger_shape_in_height(self): if hasattr(self, '_m_has_field_trigger_shape_in_height'): return self._m_has_field_trigger_shape_in_height self._m_has_field_trigger_shape_in_height = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_trigger_shape_in_height', None) @property def has_field_trigger_shape_free_interaction(self): if hasattr(self, '_m_has_field_trigger_shape_free_interaction'): return self._m_has_field_trigger_shape_free_interaction self._m_has_field_trigger_shape_free_interaction = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_trigger_shape_free_interaction', None) @property def has_field_trigger_shape_out_offset(self): if hasattr(self, '_m_has_field_trigger_shape_out_offset'): return self._m_has_field_trigger_shape_out_offset self._m_has_field_trigger_shape_out_offset = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_trigger_shape_out_offset', None) @property def has_field_trigger_shape_in_offset(self): if hasattr(self, '_m_has_field_trigger_shape_in_offset'): return self._m_has_field_trigger_shape_in_offset self._m_has_field_trigger_shape_in_offset = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_trigger_shape_in_offset', None) @property def has_field_trigger_shape_free_interaction_offset(self): if hasattr(self, '_m_has_field_trigger_shape_free_interaction_offset'): return self._m_has_field_trigger_shape_free_interaction_offset self._m_has_field_trigger_shape_free_interaction_offset = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_trigger_shape_free_interaction_offset', None) @property def has_field_trigger_shape_out(self): if hasattr(self, '_m_has_field_trigger_shape_out'): return self._m_has_field_trigger_shape_out self._m_has_field_trigger_shape_out = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_trigger_shape_out', None) @property def has_field_trigger_shape_out_height(self): if hasattr(self, '_m_has_field_trigger_shape_out_height'): return self._m_has_field_trigger_shape_out_height self._m_has_field_trigger_shape_out_height = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_trigger_shape_out_height', None) @property def has_field_trigger_shape_in(self): if hasattr(self, '_m_has_field_trigger_shape_in'): return self._m_has_field_trigger_shape_in self._m_has_field_trigger_shape_in = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_trigger_shape_in', None) @property def has_field_trigger_shape_free_interaction_height(self): if hasattr(self, '_m_has_field_trigger_shape_free_interaction_height'): return self._m_has_field_trigger_shape_free_interaction_height self._m_has_field_trigger_shape_free_interaction_height = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_trigger_shape_free_interaction_height', None) class ConfigAiSpacialProbeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_cd_max: self.cd_max = self._io.read_f4le() if self.has_field_cd_min: self.cd_min = self._io.read_f4le() if self.has_field_terrain_offset_min: self.terrain_offset_min = self._io.read_f4le() if self.has_field_terrain_offset_max: self.terrain_offset_max = self._io.read_f4le() if self.has_field_distance_from_born: self.distance_from_born = self._io.read_f4le() if self.has_field_distance_from_current_min: self.distance_from_current_min = self._io.read_f4le() if self.has_field_distance_from_current_max: self.distance_from_current_max = self._io.read_f4le() if self.has_field_probe_number_min: self.probe_number_min = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_probe_number_max: self.probe_number_max = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_cd_max(self): if hasattr(self, '_m_has_field_cd_max'): return self._m_has_field_cd_max self._m_has_field_cd_max = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_cd_max', None) @property def has_field_distance_from_current_min(self): if hasattr(self, '_m_has_field_distance_from_current_min'): return self._m_has_field_distance_from_current_min self._m_has_field_distance_from_current_min = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_distance_from_current_min', None) @property def has_field_terrain_offset_min(self): if hasattr(self, '_m_has_field_terrain_offset_min'): return self._m_has_field_terrain_offset_min self._m_has_field_terrain_offset_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_terrain_offset_min', None) @property def has_field_distance_from_born(self): if hasattr(self, '_m_has_field_distance_from_born'): return self._m_has_field_distance_from_born self._m_has_field_distance_from_born = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_distance_from_born', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_distance_from_current_max(self): if hasattr(self, '_m_has_field_distance_from_current_max'): return self._m_has_field_distance_from_current_max self._m_has_field_distance_from_current_max = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_distance_from_current_max', None) @property def has_field_cd_min(self): if hasattr(self, '_m_has_field_cd_min'): return self._m_has_field_cd_min self._m_has_field_cd_min = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_cd_min', None) @property def has_field_probe_number_min(self): if hasattr(self, '_m_has_field_probe_number_min'): return self._m_has_field_probe_number_min self._m_has_field_probe_number_min = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_probe_number_min', None) @property def has_field_probe_number_max(self): if hasattr(self, '_m_has_field_probe_number_max'): return self._m_has_field_probe_number_max self._m_has_field_probe_number_max = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_probe_number_max', None) @property def has_field_terrain_offset_max(self): if hasattr(self, '_m_has_field_terrain_offset_max'): return self._m_has_field_terrain_offset_max self._m_has_field_terrain_offset_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_terrain_offset_max', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class ConfigVehicle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_vehicle_type: self.vehicle_type = Output.EnumVehicleType(self._io, self, self._root) if self.has_field_play_mode: self.play_mode = Output.EnumPlayModeType(self._io, self, self._root) if self.has_field_camera_mode: self.camera_mode = AuxTypes.String(self._io, self, self._root) if self.has_field_max_seat_count: self.max_seat_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_seats: self.seats = Output.ArrayOfConfigVehicleSeatLengthU(self._io, self, self._root) if self.has_field_default_level: self.default_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_buff_id: self.server_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stamina: self.stamina = Output.ConfigVehicleStamina(self._io, self, self._root) @property def has_field_server_buff_id(self): if hasattr(self, '_m_has_field_server_buff_id'): return self._m_has_field_server_buff_id self._m_has_field_server_buff_id = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_server_buff_id', None) @property def has_field_vehicle_type(self): if hasattr(self, '_m_has_field_vehicle_type'): return self._m_has_field_vehicle_type self._m_has_field_vehicle_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_vehicle_type', None) @property def has_field_camera_mode(self): if hasattr(self, '_m_has_field_camera_mode'): return self._m_has_field_camera_mode self._m_has_field_camera_mode = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_camera_mode', None) @property def has_field_seats(self): if hasattr(self, '_m_has_field_seats'): return self._m_has_field_seats self._m_has_field_seats = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_seats', None) @property def has_field_play_mode(self): if hasattr(self, '_m_has_field_play_mode'): return self._m_has_field_play_mode self._m_has_field_play_mode = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_play_mode', None) @property def has_field_default_level(self): if hasattr(self, '_m_has_field_default_level'): return self._m_has_field_default_level self._m_has_field_default_level = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_default_level', None) @property def has_field_stamina(self): if hasattr(self, '_m_has_field_stamina'): return self._m_has_field_stamina self._m_has_field_stamina = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_stamina', None) @property def has_field_max_seat_count(self): if hasattr(self, '_m_has_field_max_seat_count'): return self._m_has_field_max_seat_count self._m_has_field_max_seat_count = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_seat_count', None) class TalentTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerResistDamageTextMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_types: self.element_types = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) @property def has_field_element_types(self): if hasattr(self, '_m_has_field_element_types'): return self._m_has_field_element_types self._m_has_field_element_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_types', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ExtendLifetimeByPickedGadgetMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_picked_config_i_ds: self.picked_config_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_extend_life_time: self.extend_life_time = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_max_extend_life_time: self.max_extend_life_time = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_picked_config_i_ds(self): if hasattr(self, '_m_has_field_picked_config_i_ds'): return self._m_has_field_picked_config_i_ds self._m_has_field_picked_config_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_picked_config_i_ds', None) @property def has_field_extend_life_time(self): if hasattr(self, '_m_has_field_extend_life_time'): return self._m_has_field_extend_life_time self._m_has_field_extend_life_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_extend_life_time', None) @property def has_field_max_extend_life_time(self): if hasattr(self, '_m_has_field_max_extend_life_time'): return self._m_has_field_max_extend_life_time self._m_has_field_max_extend_life_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_extend_life_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ExhibitionScoreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumMainQuestTagType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MainQuestTagType, self.data.value) return getattr(self, '_m_value', None) class ViewCodexExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigFollowMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigMove(self._io, self, self._root) self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_target: self.target = Output.EnumFollowTarget(self._io, self, self._root) if self.has_field_group_target_instance_id: self.group_target_instance_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_follow_target_ex: self.follow_target_ex = Output.DispConfigMoveFollowTarget(self._io, self, self._root) if self.has_field_attach_point: self.attach_point = AuxTypes.String(self._io, self, self._root) if self.has_field_follow_rotation: self.follow_rotation = self._io.read_u1() if self.has_field_offset: self.offset = Output.Vector(self._io, self, self._root) if self.has_field_forward: self.forward = Output.Vector(self._io, self, self._root) if self.has_field_follow_owner_invisible: self.follow_owner_invisible = self._io.read_u1() if self.has_field_fixed_y: self.fixed_y = self._io.read_f4le() if self.has_field_ignore_collision: self.ignore_collision = Output.ConfigIgnoreCollision(self._io, self, self._root) if self.has_field_move_disable_collision: self.move_disable_collision = Output.ConfigMoveDisableCollision(self._io, self, self._root) if self.has_field_move_audio: self.move_audio = Output.ConfigMoveAudio(self._io, self, self._root) if self.has_field_sync_trans_to_server: self.sync_trans_to_server = self._io.read_u1() if self.has_field_sync_interval: self.sync_interval = self._io.read_f4le() if self.has_field_handle_in_late_tick: self.handle_in_late_tick = self._io.read_u1() if self.has_field_follow_position_smoothed_damp_time: self.follow_position_smoothed_damp_time = self._io.read_f4le() if self.has_field_follow_rotation_smoothed_damp_time: self.follow_rotation_smoothed_damp_time = self._io.read_f4le() if self.has_field_follow_in_fixed_update: self.follow_in_fixed_update = self._io.read_u1() if self.has_field_fixed_follow_pos_max_speed: self.fixed_follow_pos_max_speed = self._io.read_f4le() if self.has_field_fixed_follow_rot_max_speed: self.fixed_follow_rot_max_speed = self._io.read_f4le() @property def has_field_forward(self): if hasattr(self, '_m_has_field_forward'): return self._m_has_field_forward self._m_has_field_forward = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_forward', None) @property def has_field_fixed_follow_rot_max_speed(self): if hasattr(self, '_m_has_field_fixed_follow_rot_max_speed'): return self._m_has_field_fixed_follow_rot_max_speed self._m_has_field_fixed_follow_rot_max_speed = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_fixed_follow_rot_max_speed', None) @property def has_field_move_disable_collision(self): if hasattr(self, '_m_has_field_move_disable_collision'): return self._m_has_field_move_disable_collision self._m_has_field_move_disable_collision = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_move_disable_collision', None) @property def has_field_fixed_y(self): if hasattr(self, '_m_has_field_fixed_y'): return self._m_has_field_fixed_y self._m_has_field_fixed_y = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_fixed_y', None) @property def has_field_follow_target_ex(self): if hasattr(self, '_m_has_field_follow_target_ex'): return self._m_has_field_follow_target_ex self._m_has_field_follow_target_ex = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_follow_target_ex', None) @property def has_field_follow_position_smoothed_damp_time(self): if hasattr(self, '_m_has_field_follow_position_smoothed_damp_time'): return self._m_has_field_follow_position_smoothed_damp_time self._m_has_field_follow_position_smoothed_damp_time = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_follow_position_smoothed_damp_time', None) @property def has_field_attach_point(self): if hasattr(self, '_m_has_field_attach_point'): return self._m_has_field_attach_point self._m_has_field_attach_point = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_attach_point', None) @property def has_field_offset(self): if hasattr(self, '_m_has_field_offset'): return self._m_has_field_offset self._m_has_field_offset = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_offset', None) @property def has_field_follow_rotation_smoothed_damp_time(self): if hasattr(self, '_m_has_field_follow_rotation_smoothed_damp_time'): return self._m_has_field_follow_rotation_smoothed_damp_time self._m_has_field_follow_rotation_smoothed_damp_time = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_follow_rotation_smoothed_damp_time', None) @property def has_field_group_target_instance_id(self): if hasattr(self, '_m_has_field_group_target_instance_id'): return self._m_has_field_group_target_instance_id self._m_has_field_group_target_instance_id = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_group_target_instance_id', None) @property def velocity_force(self): if hasattr(self, '_m_velocity_force'): return self._m_velocity_force self._m_velocity_force = self.base.velocity_force return getattr(self, '_m_velocity_force', None) @property def has_field_move_audio(self): if hasattr(self, '_m_has_field_move_audio'): return self._m_has_field_move_audio self._m_has_field_move_audio = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_move_audio', None) @property def handle_combat_task_immediately(self): if hasattr(self, '_m_handle_combat_task_immediately'): return self._m_handle_combat_task_immediately self._m_handle_combat_task_immediately = self.base.handle_combat_task_immediately return getattr(self, '_m_handle_combat_task_immediately', None) @property def has_field_follow_in_fixed_update(self): if hasattr(self, '_m_has_field_follow_in_fixed_update'): return self._m_has_field_follow_in_fixed_update self._m_has_field_follow_in_fixed_update = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_follow_in_fixed_update', None) @property def has_field_sync_interval(self): if hasattr(self, '_m_has_field_sync_interval'): return self._m_has_field_sync_interval self._m_has_field_sync_interval = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_sync_interval', None) @property def has_field_ignore_collision(self): if hasattr(self, '_m_has_field_ignore_collision'): return self._m_has_field_ignore_collision self._m_has_field_ignore_collision = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_ignore_collision', None) @property def has_field_fixed_follow_pos_max_speed(self): if hasattr(self, '_m_has_field_fixed_follow_pos_max_speed'): return self._m_has_field_fixed_follow_pos_max_speed self._m_has_field_fixed_follow_pos_max_speed = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_fixed_follow_pos_max_speed', None) @property def has_field_target(self): if hasattr(self, '_m_has_field_target'): return self._m_has_field_target self._m_has_field_target = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_target', None) @property def has_field_follow_owner_invisible(self): if hasattr(self, '_m_has_field_follow_owner_invisible'): return self._m_has_field_follow_owner_invisible self._m_has_field_follow_owner_invisible = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_follow_owner_invisible', None) @property def has_field_sync_trans_to_server(self): if hasattr(self, '_m_has_field_sync_trans_to_server'): return self._m_has_field_sync_trans_to_server self._m_has_field_sync_trans_to_server = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_sync_trans_to_server', None) @property def has_field_handle_in_late_tick(self): if hasattr(self, '_m_has_field_handle_in_late_tick'): return self._m_has_field_handle_in_late_tick self._m_has_field_handle_in_late_tick = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_handle_in_late_tick', None) @property def has_field_follow_rotation(self): if hasattr(self, '_m_has_field_follow_rotation'): return self._m_has_field_follow_rotation self._m_has_field_follow_rotation = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_follow_rotation', None) class AttachEffectFirework(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_pattern: self.effect_pattern = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_born: self.born = Output.DispConfigBornType(self._io, self, self._root) if self.has_field_scale: self.scale = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_effect_pattern(self): if hasattr(self, '_m_has_field_effect_pattern'): return self._m_has_field_effect_pattern self._m_has_field_effect_pattern = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_pattern', None) @property def has_field_scale(self): if hasattr(self, '_m_has_field_scale'): return self._m_has_field_scale self._m_has_field_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_scale', None) @property def has_field_born(self): if hasattr(self, '_m_has_field_born'): return self._m_has_field_born self._m_has_field_born = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_born', None) class UnlockSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ReunionWatcherExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigInputEventCheckWhiteList(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_global_white_list: self.global_white_list = Output.ArrayOfEnumInputEventTypeLengthU(self._io, self, self._root) if self.has_field_config_context_input_event_white_list_map: self.config_context_input_event_white_list_map = Output.DictOfEnumInputEventTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_global_white_list(self): if hasattr(self, '_m_has_field_global_white_list'): return self._m_has_field_global_white_list self._m_has_field_global_white_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_white_list', None) @property def has_field_config_context_input_event_white_list_map(self): if hasattr(self, '_m_has_field_config_context_input_event_white_list_map'): return self._m_has_field_config_context_input_event_white_list_map self._m_has_field_config_context_input_event_white_list_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_config_context_input_event_white_list_map', None) class ConfigParticleEffectSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_half_resolution_particle: self.half_resolution_particle = self._io.read_u1() if self.has_field_particle_emit_level: self.particle_emit_level = Output.EnumParticleEmitLevelType(self._io, self, self._root) if self.has_field_particle_decrease_thresh: self.particle_decrease_thresh = self._io.read_f4le() @property def has_field_half_resolution_particle(self): if hasattr(self, '_m_has_field_half_resolution_particle'): return self._m_has_field_half_resolution_particle self._m_has_field_half_resolution_particle = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_half_resolution_particle', None) @property def has_field_particle_emit_level(self): if hasattr(self, '_m_has_field_particle_emit_level'): return self._m_has_field_particle_emit_level self._m_has_field_particle_emit_level = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_particle_emit_level', None) @property def has_field_particle_decrease_thresh(self): if hasattr(self, '_m_has_field_particle_decrease_thresh'): return self._m_has_field_particle_decrease_thresh self._m_has_field_particle_decrease_thresh = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_particle_decrease_thresh', None) class EnumItemLimitRefreshType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ItemLimitRefreshType, self.data.value) return getattr(self, '_m_value', None) class ProductTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ShopExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AbilityCameraShotTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RandTaskExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class InvestigationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FireAiSoundEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_volume: self.volume = self._io.read_f4le() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_volume(self): if hasattr(self, '_m_has_field_volume'): return self._m_has_field_volume self._m_has_field_volume = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_volume', None) class TalkExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_begin_way: self.begin_way = Output.EnumTalkBeginWay(self._io, self, self._root) if self.has_field_active_mode: self.active_mode = Output.EnumPlayMode(self._io, self, self._root) if self.has_field_begin_cond_comb: self.begin_cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_begin_cond: self.begin_cond = Output.ArrayOfTalkCondLengthS(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_talks: self.next_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_init_dialog: self.init_dialog = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_decorator_id: self.decorator_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_random_talks: self.next_random_talks = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_random_talk_count: self.show_random_talk_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_npc_id: self.npc_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_participant_id: self.participant_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_perform_cfg: self.perform_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_hero_talk: self.hero_talk = Output.EnumTalkHeroType(self._io, self, self._root) if self.has_field_load_type: self.load_type = Output.EnumTalkLoadType(self._io, self, self._root) if self.has_field_quest_id: self.quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_extra_load_mark_id: self.extra_load_mark_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_dont_block_daily: self.dont_block_daily = self._io.read_u1() if self.has_field_pre_perform_cfg: self.pre_perform_cfg = AuxTypes.String(self._io, self, self._root) if self.has_field_stay_free_style: self.stay_free_style = self._io.read_u1() if self.has_field_enable_camera_displacement: self.enable_camera_displacement = self._io.read_u1() if self.has_field_lock_game_time: self.lock_game_time = self._io.read_u1() if self.has_field_talk_mark_type: self.talk_mark_type = Output.EnumTalkMarkType(self._io, self, self._root) if self.has_field_talk_mark_hide_list: self.talk_mark_hide_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_crowd_lod0list: self.crowd_lod0list = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_quest_idle_talk: self.quest_idle_talk = self._io.read_u1() if self.has_field_low_priority: self.low_priority = self._io.read_u1() if self.has_field_finish_exec: self.finish_exec = Output.ArrayOfTalkExecLengthS(self._io, self, self._root) @property def has_field_participant_id(self): if hasattr(self, '_m_has_field_participant_id'): return self._m_has_field_participant_id self._m_has_field_participant_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_participant_id', None) @property def has_field_perform_cfg(self): if hasattr(self, '_m_has_field_perform_cfg'): return self._m_has_field_perform_cfg self._m_has_field_perform_cfg = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_perform_cfg', None) @property def has_field_quest_idle_talk(self): if hasattr(self, '_m_has_field_quest_idle_talk'): return self._m_has_field_quest_idle_talk self._m_has_field_quest_idle_talk = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 4) != 0)) return getattr(self, '_m_has_field_quest_idle_talk', None) @property def has_field_init_dialog(self): if hasattr(self, '_m_has_field_init_dialog'): return self._m_has_field_init_dialog self._m_has_field_init_dialog = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_init_dialog', None) @property def has_field_lock_game_time(self): if hasattr(self, '_m_has_field_lock_game_time'): return self._m_has_field_lock_game_time self._m_has_field_lock_game_time = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 64) != 0)) return getattr(self, '_m_has_field_lock_game_time', None) @property def has_field_begin_way(self): if hasattr(self, '_m_has_field_begin_way'): return self._m_has_field_begin_way self._m_has_field_begin_way = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_begin_way', None) @property def has_field_next_talks(self): if hasattr(self, '_m_has_field_next_talks'): return self._m_has_field_next_talks self._m_has_field_next_talks = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_next_talks', None) @property def has_field_pre_perform_cfg(self): if hasattr(self, '_m_has_field_pre_perform_cfg'): return self._m_has_field_pre_perform_cfg self._m_has_field_pre_perform_cfg = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 8) != 0)) return getattr(self, '_m_has_field_pre_perform_cfg', None) @property def has_field_begin_cond_comb(self): if hasattr(self, '_m_has_field_begin_cond_comb'): return self._m_has_field_begin_cond_comb self._m_has_field_begin_cond_comb = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_begin_cond_comb', None) @property def has_field_extra_load_mark_id(self): if hasattr(self, '_m_has_field_extra_load_mark_id'): return self._m_has_field_extra_load_mark_id self._m_has_field_extra_load_mark_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_extra_load_mark_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_next_random_talks(self): if hasattr(self, '_m_has_field_next_random_talks'): return self._m_has_field_next_random_talks self._m_has_field_next_random_talks = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_next_random_talks', None) @property def has_field_talk_mark_type(self): if hasattr(self, '_m_has_field_talk_mark_type'): return self._m_has_field_talk_mark_type self._m_has_field_talk_mark_type = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 128) != 0)) return getattr(self, '_m_has_field_talk_mark_type', None) @property def has_field_crowd_lod0list(self): if hasattr(self, '_m_has_field_crowd_lod0list'): return self._m_has_field_crowd_lod0list self._m_has_field_crowd_lod0list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 2) != 0)) return getattr(self, '_m_has_field_crowd_lod0list', None) @property def has_field_decorator_id(self): if hasattr(self, '_m_has_field_decorator_id'): return self._m_has_field_decorator_id self._m_has_field_decorator_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_decorator_id', None) @property def has_field_finish_exec(self): if hasattr(self, '_m_has_field_finish_exec'): return self._m_has_field_finish_exec self._m_has_field_finish_exec = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 16) != 0)) return getattr(self, '_m_has_field_finish_exec', None) @property def has_field_dont_block_daily(self): if hasattr(self, '_m_has_field_dont_block_daily'): return self._m_has_field_dont_block_daily self._m_has_field_dont_block_daily = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 4) != 0)) return getattr(self, '_m_has_field_dont_block_daily', None) @property def has_field_enable_camera_displacement(self): if hasattr(self, '_m_has_field_enable_camera_displacement'): return self._m_has_field_enable_camera_displacement self._m_has_field_enable_camera_displacement = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 32) != 0)) return getattr(self, '_m_has_field_enable_camera_displacement', None) @property def has_field_show_random_talk_count(self): if hasattr(self, '_m_has_field_show_random_talk_count'): return self._m_has_field_show_random_talk_count self._m_has_field_show_random_talk_count = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_show_random_talk_count', None) @property def has_field_begin_cond(self): if hasattr(self, '_m_has_field_begin_cond'): return self._m_has_field_begin_cond self._m_has_field_begin_cond = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_begin_cond', None) @property def has_field_quest_id(self): if hasattr(self, '_m_has_field_quest_id'): return self._m_has_field_quest_id self._m_has_field_quest_id = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_quest_id', None) @property def has_field_active_mode(self): if hasattr(self, '_m_has_field_active_mode'): return self._m_has_field_active_mode self._m_has_field_active_mode = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_active_mode', None) @property def has_field_load_type(self): if hasattr(self, '_m_has_field_load_type'): return self._m_has_field_load_type self._m_has_field_load_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_load_type', None) @property def has_field_talk_mark_hide_list(self): if hasattr(self, '_m_has_field_talk_mark_hide_list'): return self._m_has_field_talk_mark_hide_list self._m_has_field_talk_mark_hide_list = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 1) != 0)) return getattr(self, '_m_has_field_talk_mark_hide_list', None) @property def has_field_npc_id(self): if hasattr(self, '_m_has_field_npc_id'): return self._m_has_field_npc_id self._m_has_field_npc_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_npc_id', None) @property def has_field_low_priority(self): if hasattr(self, '_m_has_field_low_priority'): return self._m_has_field_low_priority self._m_has_field_low_priority = ((self.bit_field.length.value >= (3 + 1)) and ((self.bit_field.bitfield[3] & 8) != 0)) return getattr(self, '_m_has_field_low_priority', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_hero_talk(self): if hasattr(self, '_m_has_field_hero_talk'): return self._m_has_field_hero_talk self._m_has_field_hero_talk = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_hero_talk', None) @property def has_field_stay_free_style(self): if hasattr(self, '_m_has_field_stay_free_style'): return self._m_has_field_stay_free_style self._m_has_field_stay_free_style = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 16) != 0)) return getattr(self, '_m_has_field_stay_free_style', None) class DispConfigMusicCondition(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 14: self.data = Output.ConfigMusicUInt32listCondition(self._io, self, self._root) elif _on == 10: self.data = Output.ConfigMusicSingleCondition(self._io, self, self._root) elif _on == 17: self.data = Output.ConfigMusicInt32greaterThanCondition(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigMusicCondition(self._io, self, self._root) elif _on == 47: self.data = Output.ConfigMusicUInt32listNonePresenceCondition(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigMusicParameterCondition(self._io, self, self._root) elif _on == 42: self.data = Output.ConfigMusicUInt32listMemberCondition(self._io, self, self._root) elif _on == 46: self.data = Output.ConfigMusicUInt32listAllPresenceCondition(self._io, self, self._root) elif _on == 39: self.data = Output.ConfigMusicStringEqualityCondition(self._io, self, self._root) elif _on == 24: self.data = Output.ConfigMusicUInt32lessThanCondition(self._io, self, self._root) elif _on == 35: self.data = Output.ConfigMusicDoubleGreaterThanCondition(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigMusicDisjunctiveCondition(self._io, self, self._root) elif _on == 20: self.data = Output.ConfigMusicInt32noLessThanCondition(self._io, self, self._root) elif _on == 32: self.data = Output.ConfigMusicSingleNoLessThanCondition(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigMusicInt32condition(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigMusicTrueCondition(self._io, self, self._root) elif _on == 27: self.data = Output.ConfigMusicSingleEqualityCondition(self._io, self, self._root) elif _on == 13: self.data = Output.ConfigMusicStringCondition(self._io, self, self._root) elif _on == 45: self.data = Output.ConfigMusicUInt32listAbsenceCondition(self._io, self, self._root) elif _on == 11: self.data = Output.ConfigMusicDoubleCondition(self._io, self, self._root) elif _on == 12: self.data = Output.ConfigMusicBooleanCondition(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigMusicBinaryCondition(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigMusicConjunctiveCondition(self._io, self, self._root) elif _on == 33: self.data = Output.ConfigMusicDoubleEqualityCondition(self._io, self, self._root) elif _on == 19: self.data = Output.ConfigMusicInt32noGreaterThanCondition(self._io, self, self._root) elif _on == 23: self.data = Output.ConfigMusicUInt32greaterThanCondition(self._io, self, self._root) elif _on == 48: self.data = Output.ConfigMusicUInt32listPartialPresenceCondition(self._io, self, self._root) elif _on == 15: self.data = Output.ConfigMusicInt32equalityCondition(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigMusicUInt32condition(self._io, self, self._root) elif _on == 38: self.data = Output.ConfigMusicDoubleNoLessThanCondition(self._io, self, self._root) elif _on == 40: self.data = Output.ConfigMusicStringContainmentCondition(self._io, self, self._root) elif _on == 44: self.data = Output.ConfigMusicUInt32listPresenceCondition(self._io, self, self._root) elif _on == 9: self.data = Output.ConfigMusicUInt32multiCondition(self._io, self, self._root) elif _on == 21: self.data = Output.ConfigMusicUInt32equalityCondition(self._io, self, self._root) elif _on == 37: self.data = Output.ConfigMusicDoubleNoGreaterThanCondition(self._io, self, self._root) elif _on == 41: self.data = Output.ConfigMusicUInt32listEmptinessCondition(self._io, self, self._root) elif _on == 36: self.data = Output.ConfigMusicDoubleLessThanCondition(self._io, self, self._root) elif _on == 28: self.data = Output.ConfigMusicSingleInequalityCondition(self._io, self, self._root) elif _on == 16: self.data = Output.ConfigMusicInt32inequalityCondition(self._io, self, self._root) elif _on == 18: self.data = Output.ConfigMusicInt32lessThanCondition(self._io, self, self._root) elif _on == 26: self.data = Output.ConfigMusicUInt32noLessThanCondition(self._io, self, self._root) elif _on == 31: self.data = Output.ConfigMusicSingleNoGreaterThanCondition(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigMusicNegativeCondition(self._io, self, self._root) elif _on == 34: self.data = Output.ConfigMusicDoubleInequalityCondition(self._io, self, self._root) elif _on == 29: self.data = Output.ConfigMusicSingleGreaterThanCondition(self._io, self, self._root) elif _on == 25: self.data = Output.ConfigMusicUInt32noGreaterThanCondition(self._io, self, self._root) elif _on == 43: self.data = Output.ConfigMusicUInt32listMultiMemberCondition(self._io, self, self._root) elif _on == 22: self.data = Output.ConfigMusicUInt32inequalityCondition(self._io, self, self._root) elif _on == 30: self.data = Output.ConfigMusicSingleLessThanCondition(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class EnumPerfConfigPlatform(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfConfigPlatform, self.data.value) return getattr(self, '_m_value', None) class DispConfigMist(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigMist(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigErosionArea(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigLevelTagArea(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class KvpOfDictAuxTypesVlqBase128LeUDispConfigJudgeNodeBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.DispConfigJudgeNodeBase(self._io, self, self._root) class EnumActionTokenSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActionTokenSourceType, self.data.value) return getattr(self, '_m_value', None) class ConfigAiSpacialProbeSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiSpacialProbeData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiSpacialProbeData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ByEntityAppearVisionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_vision_type: self.vision_type = Output.EnumEntityAppearVisionType(self._io, self, self._root) @property def has_field_vision_type(self): if hasattr(self, '_m_has_field_vision_type'): return self._m_has_field_vision_type self._m_has_field_vision_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_vision_type', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class PileTagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MainQuestTagTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TrialAvatarActivityDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumConfigPreloadTypeArrayOfAuxTypesStringLengthU(self._io, self, self._root)) class EnumDamageClampType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DamageClampType, self.data.value) return getattr(self, '_m_value', None) class ConfigBaseWidgetToy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_is_consume_material: self.is_consume_material = self._io.read_u1() if self.has_field_cd_group: self.cd_group = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_tags: self.tags = Output.ArrayOfEnumWidgetOccupyTagLengthU(self._io, self, self._root) if self.has_field_business_type: self.business_type = Output.EnumWidgetBusinessType(self._io, self, self._root) @property def has_field_is_consume_material(self): if hasattr(self, '_m_has_field_is_consume_material'): return self._m_has_field_is_consume_material self._m_has_field_is_consume_material = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_consume_material', None) @property def has_field_cd_group(self): if hasattr(self, '_m_has_field_cd_group'): return self._m_has_field_cd_group self._m_has_field_cd_group = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_group', None) @property def has_field_tags(self): if hasattr(self, '_m_has_field_tags'): return self._m_has_field_tags self._m_has_field_tags = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_tags', None) @property def has_field_business_type(self): if hasattr(self, '_m_has_field_business_type'): return self._m_has_field_business_type self._m_has_field_business_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_business_type', None) class ArrayOfRecordOverrideTextureLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.RecordOverrideTexture(self._io, self, self._root)) class KvpOfDictAuxTypesStringArrayOfConfigGadgetUiItemGroupShowCondLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfConfigGadgetUiItemGroupShowCondLengthU(self._io, self, self._root) class DigStageDataExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMoveFollowTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPickupMulti(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dir_min_vec: self.dir_min_vec = Output.Vector(self._io, self, self._root) if self.has_field_dir_max_vec: self.dir_max_vec = Output.Vector(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_num: self.min_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attract_speed: self.attract_speed = self._io.read_f4le() if self.has_field_use_world_trans: self.use_world_trans = self._io.read_u1() if self.has_field_is_auto_attract: self.is_auto_attract = self._io.read_u1() @property def has_field_min_num(self): if hasattr(self, '_m_has_field_min_num'): return self._m_has_field_min_num self._m_has_field_min_num = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_num', None) @property def has_field_use_world_trans(self): if hasattr(self, '_m_has_field_use_world_trans'): return self._m_has_field_use_world_trans self._m_has_field_use_world_trans = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_use_world_trans', None) @property def has_field_is_auto_attract(self): if hasattr(self, '_m_has_field_is_auto_attract'): return self._m_has_field_is_auto_attract self._m_has_field_is_auto_attract = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_is_auto_attract', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_num', None) @property def has_field_attract_speed(self): if hasattr(self, '_m_has_field_attract_speed'): return self._m_has_field_attract_speed self._m_has_field_attract_speed = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_attract_speed', None) @property def has_field_dir_min_vec(self): if hasattr(self, '_m_has_field_dir_min_vec'): return self._m_has_field_dir_min_vec self._m_has_field_dir_min_vec = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dir_min_vec', None) @property def has_field_dir_max_vec(self): if hasattr(self, '_m_has_field_dir_max_vec'): return self._m_has_field_dir_max_vec self._m_has_field_dir_max_vec = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dir_max_vec', None) class ArrayOfShopmallRecommendCondLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ShopmallRecommendCond(self._io, self, self._root)) class IrodoriChessDisorderExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RoundTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumProjectionGameGuideType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ProjectionGameGuideType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfEnumElementTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumElementType(self._io, self, self._root)) class KvpOfDictAuxTypesVlqBase128LeSConfigAiSpacialFacingMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiSpacialFacingMoveData(self._io, self, self._root) class ConfigWidgetToyCrystal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigWidgetUseAttachAbilityTrigger(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_energy_cost: self.energy_cost = self._io.read_f4le() if self.has_field_meter_type: self.meter_type = Output.EnumRegionalPlayVarType(self._io, self, self._root) @property def is_team(self): if hasattr(self, '_m_is_team'): return self._m_is_team self._m_is_team = self.base.is_team return getattr(self, '_m_is_team', None) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def ability_group_name(self): if hasattr(self, '_m_ability_group_name'): return self._m_ability_group_name self._m_ability_group_name = self.base.ability_group_name return getattr(self, '_m_ability_group_name', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_meter_type(self): if hasattr(self, '_m_has_field_meter_type'): return self._m_has_field_meter_type self._m_has_field_meter_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_meter_type', None) @property def has_field_energy_cost(self): if hasattr(self, '_m_has_field_energy_cost'): return self._m_has_field_energy_cost self._m_has_field_energy_cost = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_energy_cost', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) @property def trigger_ability_name(self): if hasattr(self, '_m_trigger_ability_name'): return self._m_trigger_ability_name self._m_trigger_ability_name = self.base.trigger_ability_name return getattr(self, '_m_trigger_ability_name', None) class MusicBehaviourIgnoranceComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigAbilityMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 120: self.data = Output.DummyMixin(self._io, self, self._root) elif _on == 141: self.data = Output.WidgetMpSupportMixin(self._io, self, self._root) elif _on == 93: self.data = Output.TileAttackManagerMixin(self._io, self, self._root) elif _on == 118: self.data = Output.MoveStateMixin(self._io, self, self._root) elif _on == 159: self.data = Output.ChangeLockTypeMixin(self._io, self, self._root) elif _on == 194: self.data = Output.DamageStatisticsMixin(self._io, self, self._root) elif _on == 184: self.data = Output.DoActionBySelfElementReactionMixin(self._io, self, self._root) elif _on == 105: self.data = Output.PlayerUidNotifyMixin(self._io, self, self._root) elif _on == 142: self.data = Output.FollowAttachPointEffectMixin(self._io, self, self._root) elif _on == 14: self.data = Output.ButtonHoldChargeMixin(self._io, self, self._root) elif _on == 61: self.data = Output.HitLevelGaugeMixin(self._io, self, self._root) elif _on == 10: self.data = Output.AttachModifierByStackingMixin(self._io, self, self._root) elif _on == 112: self.data = Output.ResistClimateMixin(self._io, self, self._root) elif _on == 177: self.data = Output.OnLevelTagChangeMixin(self._io, self, self._root) elif _on == 163: self.data = Output.RigidBodyFreezeMixin(self._io, self, self._root) elif _on == 17: self.data = Output.SteerAttackMixin(self._io, self, self._root) elif _on == 131: self.data = Output.EntityDitherMixin(self._io, self, self._root) elif _on == 0: self.data = Output.ConfigAbilityMixin(self._io, self, self._root) elif _on == 167: self.data = Output.DoActionBySelfModifierElementDurabilityRatioMixin(self._io, self, self._root) elif _on == 146: self.data = Output.AiPerceptionMixin(self._io, self, self._root) elif _on == 47: self.data = Output.TriggerSkillRadialBlurMixin(self._io, self, self._root) elif _on == 136: self.data = Output.HomeworldServerEventMixin(self._io, self, self._root) elif _on == 73: self.data = Output.DvalinS01pathEffsMixin(self._io, self, self._root) elif _on == 4: self.data = Output.AttachToStateIdMixin(self._io, self, self._root) elif _on == 42: self.data = Output.BeingHitMixin(self._io, self, self._root) elif _on == 46: self.data = Output.TriggerPostProcessEffectMixin(self._io, self, self._root) elif _on == 81: self.data = Output.DoActionByAnimatorStateIdMixin(self._io, self, self._root) elif _on == 169: self.data = Output.DoActionByEntityKillMixin(self._io, self, self._root) elif _on == 162: self.data = Output.DigAttachModifierToTargetDistanceMixin(self._io, self, self._root) elif _on == 116: self.data = Output.BillboardFixedMarkMixin(self._io, self, self._root) elif _on == 39: self.data = Output.OnLocalAvatarAddedShieldMixin(self._io, self, self._root) elif _on == 60: self.data = Output.IceFloorMixin(self._io, self, self._root) elif _on == 119: self.data = Output.ServerFinishWatcherMixin(self._io, self, self._root) elif _on == 24: self.data = Output.AttachModifierToSelfGlobalValueNoInitMixin(self._io, self, self._root) elif _on == 35: self.data = Output.SwitchSkillIdMixin(self._io, self, self._root) elif _on == 6: self.data = Output.AttachToNormalizedTimeMixin(self._io, self, self._root) elif _on == 62: self.data = Output.RecycleModifierMixin(self._io, self, self._root) elif _on == 20: self.data = Output.ElementShieldMixin(self._io, self, self._root) elif _on == 32: self.data = Output.VelocityDetectMixin(self._io, self, self._root) elif _on == 7: self.data = Output.AttachToPoseIdMixin(self._io, self, self._root) elif _on == 202: self.data = Output.TriggerBeHitSupportMixin(self._io, self, self._root) elif _on == 113: self.data = Output.ServerUpdateGlobalValueMixin(self._io, self, self._root) elif _on == 121: self.data = Output.UrgentHotFixMixin(self._io, self, self._root) elif _on == 96: self.data = Output.MonsterReadyMixin(self._io, self, self._root) elif _on == 191: self.data = Output.AttachModifierByActivityGachaStageMixin(self._io, self, self._root) elif _on == 1: self.data = Output.DebugMixin(self._io, self, self._root) elif _on == 55: self.data = Output.ApplyInertiaVelocityMixin(self._io, self, self._root) elif _on == 27: self.data = Output.WindZoneMixin(self._io, self, self._root) elif _on == 150: self.data = Output.ElectricCoreMoveMixin(self._io, self, self._root) elif _on == 97: self.data = Output.DoActionByKillingMixin(self._io, self, self._root) elif _on == 77: self.data = Output.StageReadyMixin(self._io, self, self._root) elif _on == 106: self.data = Output.AttachToPlayStageMixin(self._io, self, self._root) elif _on == 13: self.data = Output.DoActionByEventMixin(self._io, self, self._root) elif _on == 145: self.data = Output.DynamicCollisionMixin(self._io, self, self._root) elif _on == 52: self.data = Output.RejectAttackMixin(self._io, self, self._root) elif _on == 56: self.data = Output.ChangePropTypeValueMixin(self._io, self, self._root) elif _on == 101: self.data = Output.AttachToAbilityStateMixin(self._io, self, self._root) elif _on == 144: self.data = Output.ElementConvertToChargeBarValueMixin(self._io, self, self._root) elif _on == 127: self.data = Output.VelocityForceMixin(self._io, self, self._root) elif _on == 100: self.data = Output.AttachToElementTypeMixin(self._io, self, self._root) elif _on == 45: self.data = Output.TriggerWeatherMixin(self._io, self, self._root) elif _on == 87: self.data = Output.AttachModifierToHpPercentMixinV2(self._io, self, self._root) elif _on == 149: self.data = Output.ConnectLineMixin(self._io, self, self._root) elif _on == 115: self.data = Output.BillboardMarkMixin(self._io, self, self._root) elif _on == 66: self.data = Output.AttachToDayNightMixin(self._io, self, self._root) elif _on == 91: self.data = Output.TileAttackMixin(self._io, self, self._root) elif _on == 107: self.data = Output.ServerCreateGadgetOnKillMixin(self._io, self, self._root) elif _on == 143: self.data = Output.MultiBadmintonShootMixin(self._io, self, self._root) elif _on == 89: self.data = Output.DoActionByElementReactionMixin(self._io, self, self._root) elif _on == 104: self.data = Output.ApplyModifierWithSharedDurabilityMixin(self._io, self, self._root) elif _on == 98: self.data = Output.ShaderLerpMixin(self._io, self, self._root) elif _on == 85: self.data = Output.GlobalSubShieldMixin(self._io, self, self._root) elif _on == 201: self.data = Output.TriggerElementSupportMixin(self._io, self, self._root) elif _on == 197: self.data = Output.SteerAttackTraceMixin(self._io, self, self._root) elif _on == 11: self.data = Output.AttachToAiAlertnessMixin(self._io, self, self._root) elif _on == 67: self.data = Output.DoActionByCreateGadgetMixin(self._io, self, self._root) elif _on == 69: self.data = Output.EnviroFollowRotateMixin(self._io, self, self._root) elif _on == 95: self.data = Output.TileComplexManagerMixin(self._io, self, self._root) elif _on == 137: self.data = Output.GadgetUpgradeChainMixin(self._io, self, self._root) elif _on == 12: self.data = Output.AttachModifierToPredicateMixin(self._io, self, self._root) elif _on == 59: self.data = Output.DoReviveMixin(self._io, self, self._root) elif _on == 88: self.data = Output.DoActionByTeamStatusMixin(self._io, self, self._root) elif _on == 161: self.data = Output.ReplaceFaceAnimationMixin(self._io, self, self._root) elif _on == 138: self.data = Output.InteractTriggerAbility(self._io, self, self._root) elif _on == 58: self.data = Output.DoActionByEnergyChangeMixin(self._io, self, self._root) elif _on == 3: self.data = Output.ReplaceEventPatternMixin(self._io, self, self._root) elif _on == 192: self.data = Output.AddAvatarInCdMixin(self._io, self, self._root) elif _on == 126: self.data = Output.CircleBarrageMixin(self._io, self, self._root) elif _on == 165: self.data = Output.DiePatternSwitchMixin(self._io, self, self._root) elif _on == 5: self.data = Output.AttachToMonsterAirStateMixin(self._io, self, self._root) elif _on == 33: self.data = Output.WeightDetectRegionMixin(self._io, self, self._root) elif _on == 103: self.data = Output.ElementOuterGlowEffectMixin(self._io, self, self._root) elif _on == 205: self.data = Output.AutoDefenceMixin(self._io, self, self._root) elif _on == 99: self.data = Output.ElementAdjustMixin(self._io, self, self._root) elif _on == 82: self.data = Output.DoActionByPoseIdMixin(self._io, self, self._root) elif _on == 185: self.data = Output.SetAnimationPauseByAbilityStateMixin(self._io, self, self._root) elif _on == 86: self.data = Output.AttachModifierToHpPercentMixin(self._io, self, self._root) elif _on == 180: self.data = Output.MonsterLaunchMixin(self._io, self, self._root) elif _on == 156: self.data = Output.ClampDamageReceivedMixin(self._io, self, self._root) elif _on == 125: self.data = Output.ModifyCameraMaxDistanceMixin(self._io, self, self._root) elif _on == 19: self.data = Output.ChargeBarMixin(self._io, self, self._root) elif _on == 203: self.data = Output.TriggerRageSupportMixin(self._io, self, self._root) elif _on == 84: self.data = Output.GlobalMainShieldMixin(self._io, self, self._root) elif _on == 63: self.data = Output.CurLocalAvatarMixin(self._io, self, self._root) elif _on == 186: self.data = Output.BaseSwitchMixin(self._io, self, self._root) elif _on == 51: self.data = Output.ReviveElemEnergyMixin(self._io, self, self._root) elif _on == 23: self.data = Output.AttachModifierToSelfGlobalValueMixin(self._io, self, self._root) elif _on == 83: self.data = Output.OverrideStickElemUiMixin(self._io, self, self._root) elif _on == 188: self.data = Output.OnParentAbilityStartMixin(self._io, self, self._root) elif _on == 48: self.data = Output.ModifyDamageMixin(self._io, self, self._root) elif _on == 153: self.data = Output.ElectricCoreLineMixin(self._io, self, self._root) elif _on == 178: self.data = Output.RoomRotateGadgetStateMixin(self._io, self, self._root) elif _on == 123: self.data = Output.TdPlayMixin(self._io, self, self._root) elif _on == 78: self.data = Output.AttachModifierToElementDurabilityMixin(self._io, self, self._root) elif _on == 53: self.data = Output.RejectAttackMixinV2(self._io, self, self._root) elif _on == 15: self.data = Output.SkillButtonHoldChargeMixin(self._io, self, self._root) elif _on == 160: self.data = Output.EffectChangeAlphaMixin(self._io, self, self._root) elif _on == 174: self.data = Output.UnitDurationMixin(self._io, self, self._root) elif _on == 176: self.data = Output.EntityDisplacementMixin(self._io, self, self._root) elif _on == 8: self.data = Output.AttachToGadgetStateMixin(self._io, self, self._root) elif _on == 166: self.data = Output.AttackReviveEnergyMixin(self._io, self, self._root) elif _on == 38: self.data = Output.OnAvatarUseSkillMixin(self._io, self, self._root) elif _on == 114: self.data = Output.ElementReactionShockMixin(self._io, self, self._root) elif _on == 181: self.data = Output.MonsterLandMixin(self._io, self, self._root) elif _on == 40: self.data = Output.CostStaminaMixin(self._io, self, self._root) elif _on == 207: self.data = Output.RocketJumpMixin(self._io, self, self._root) elif _on == 204: self.data = Output.MonsterDefendMixin(self._io, self, self._root) elif _on == 148: self.data = Output.OverrideMonsterMoveSpeedRatioMixin(self._io, self, self._root) elif _on == 158: self.data = Output.AttachModifierToClimateMeterMixin(self._io, self, self._root) elif _on == 117: self.data = Output.AttachModifierToTargetDistanceMixin(self._io, self, self._root) elif _on == 64: self.data = Output.LocalAvatarsMixin(self._io, self, self._root) elif _on == 152: self.data = Output.FishingAimParabolaMixin(self._io, self, self._root) elif _on == 65: self.data = Output.CurLocalAvatarMixinV2(self._io, self, self._root) elif _on == 94: self.data = Output.DoTileActionManagerMixin(self._io, self, self._root) elif _on == 44: self.data = Output.TriggerWitchTimeMixin(self._io, self, self._root) elif _on == 76: self.data = Output.TriggerResistDamageTextMixin(self._io, self, self._root) elif _on == 109: self.data = Output.DoActionByGainCrystalSeedMixin(self._io, self, self._root) elif _on == 206: self.data = Output.ModifyDamageCountMixin(self._io, self, self._root) elif _on == 79: self.data = Output.AttachModifierToSurfaceTypeMixin(self._io, self, self._root) elif _on == 57: self.data = Output.ExtendLifetimeByPickedGadgetMixin(self._io, self, self._root) elif _on == 140: self.data = Output.AttachToWidgetStateMixin(self._io, self, self._root) elif _on == 122: self.data = Output.FieldEntityCountChangeMixin(self._io, self, self._root) elif _on == 179: self.data = Output.CameraSetReflectionMixin(self._io, self, self._root) elif _on == 9: self.data = Output.AttachToGadgetStateMutexMixin(self._io, self, self._root) elif _on == 195: self.data = Output.AttachToAnimatorStateIdMixin(self._io, self, self._root) elif _on == 172: self.data = Output.HideAvatarSkillMixin(self._io, self, self._root) elif _on == 130: self.data = Output.EntityMarkShowTypeMixin(self._io, self, self._root) elif _on == 187: self.data = Output.AttachActionToModifierMixin(self._io, self, self._root) elif _on == 21: self.data = Output.EliteShieldMixin(self._io, self, self._root) elif _on == 170: self.data = Output.EnableCharacterMoveOnWaterMixin(self._io, self, self._root) elif _on == 37: self.data = Output.AvatarLevelSkillMixin(self._io, self, self._root) elif _on == 199: self.data = Output.AttachModifierToSelfGlobalValueAndTalkStateMixin(self._io, self, self._root) elif _on == 164: self.data = Output.DoActionOnGlobalValueChangeMixin(self._io, self, self._root) elif _on == 182: self.data = Output.GrapplingHookMoveMixin(self._io, self, self._root) elif _on == 108: self.data = Output.CameraBlurMixin(self._io, self, self._root) elif _on == 189: self.data = Output.PlatformMoveMixin(self._io, self, self._root) elif _on == 41: self.data = Output.EntityDefenceMixin(self._io, self, self._root) elif _on == 72: self.data = Output.FixDvalinS04moveMixin(self._io, self, self._root) elif _on == 71: self.data = Output.DvalinS01boxMoxeMixin(self._io, self, self._root) elif _on == 168: self.data = Output.WidgetCdSyncMixin(self._io, self, self._root) elif _on == 171: self.data = Output.ExcludeGravityMixin(self._io, self, self._root) elif _on == 36: self.data = Output.AvatarChangeSkillMixin(self._io, self, self._root) elif _on == 70: self.data = Output.BoxClampWindZoneMixin(self._io, self, self._root) elif _on == 28: self.data = Output.TornadoMixin(self._io, self, self._root) elif _on == 193: self.data = Output.VehicleSkillDepotChangeMixin(self._io, self, self._root) elif _on == 133: self.data = Output.SetSkillCanUseInStateMixin(self._io, self, self._root) elif _on == 129: self.data = Output.BanEntityMarkMixin(self._io, self, self._root) elif _on == 74: self.data = Output.CameraLockMixin(self._io, self, self._root) elif _on == 151: self.data = Output.SendPostionToShaderCutMixin(self._io, self, self._root) elif _on == 157: self.data = Output.DoActionByDamageReceivedMixin(self._io, self, self._root) elif _on == 16: self.data = Output.AvatarSteerByCameraMixin(self._io, self, self._root) elif _on == 147: self.data = Output.AttachModifierByNeuronMixin(self._io, self, self._root) elif _on == 134: self.data = Output.GadgetChargeMixin(self._io, self, self._root) elif _on == 18: self.data = Output.ShieldBarMixin(self._io, self, self._root) elif _on == 80: self.data = Output.DoActionByStateIdMixin(self._io, self, self._root) elif _on == 102: self.data = Output.WatcherSystemMixin(self._io, self, self._root) elif _on == 68: self.data = Output.FireworksLauncherMixin(self._io, self, self._root) elif _on == 110: self.data = Output.ModifyElementDecrateMixin(self._io, self, self._root) elif _on == 26: self.data = Output.TriggerTypeSupportMixin(self._io, self, self._root) elif _on == 139: self.data = Output.InteractTriggerAbilityMixin(self._io, self, self._root) elif _on == 155: self.data = Output.SelfAddDurabilityMixin(self._io, self, self._root) elif _on == 31: self.data = Output.CollisionMixin(self._io, self, self._root) elif _on == 49: self.data = Output.ClusterTriggerMixin(self._io, self, self._root) elif _on == 2: self.data = Output.RelyOnElementMixin(self._io, self, self._root) elif _on == 135: self.data = Output.HomeworldEnterEditorMixin(self._io, self, self._root) elif _on == 124: self.data = Output.TdPlayMixinV2(self._io, self, self._root) elif _on == 34: self.data = Output.ChangeFieldMixin(self._io, self, self._root) elif _on == 200: self.data = Output.AttachModifierToSelfGlobalValueAndTalkStateNoInitMixin(self._io, self, self._root) elif _on == 54: self.data = Output.AttackCostElementMixin(self._io, self, self._root) elif _on == 29: self.data = Output.AirFlowMixin(self._io, self, self._root) elif _on == 132: self.data = Output.EntityInVisibleMixin(self._io, self, self._root) elif _on == 175: self.data = Output.UgcTimeControlMixin(self._io, self, self._root) elif _on == 75: self.data = Output.AvatarLockForwardFlyMixin(self._io, self, self._root) elif _on == 92: self.data = Output.TileComplexMixin(self._io, self, self._root) elif _on == 198: self.data = Output.SteerAttackTraceToPosMixin(self._io, self, self._root) elif _on == 111: self.data = Output.ElementHittingOtherPredicatedMixin(self._io, self, self._root) elif _on == 190: self.data = Output.EnableSprintInBlackMudMixin(self._io, self, self._root) elif _on == 25: self.data = Output.AttachModifierToGlobalValueMixin(self._io, self, self._root) elif _on == 43: self.data = Output.AttackHittingSceneMixin(self._io, self, self._root) elif _on == 196: self.data = Output.SteerAttackMoveMixin(self._io, self, self._root) elif _on == 50: self.data = Output.ModifySkillCdByModifierCountMixin(self._io, self, self._root) elif _on == 22: self.data = Output.OverrideAttackEventMixin(self._io, self, self._root) elif _on == 30: self.data = Output.WindSeedSpawnerMixin(self._io, self, self._root) elif _on == 183: self.data = Output.EnableManualOcclusionMixin(self._io, self, self._root) elif _on == 173: self.data = Output.DoActionByRayTagMixin(self._io, self, self._root) elif _on == 128: self.data = Output.ScenePropSyncMixin(self._io, self, self._root) elif _on == 90: self.data = Output.AnimatorRotationCompensateMixin(self._io, self, self._root) elif _on == 154: self.data = Output.StreamingModifierMixin(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class DispConfigClimateInfoBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigClimateInfoBase(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigClimateInfo(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class SectrStreamObjectRuntimeNativeRef(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityMultiPlayerExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumAnimeGroupTypeConfigAnimGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumAnimeGroupTypeConfigAnimGroup(self._io, self, self._root)) class StateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumSteerAttackTargetTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumSteerAttackTargetType(self._io, self, self._root)) class DictOfAuxTypesVlqBase128LeSConfigAiExtractionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSConfigAiExtractionData(self._io, self, self._root)) class AvatarSkillStart(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_skill_id: self.skill_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cd_ratio: self.cd_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_cost_stamina_ratio: self.cost_stamina_ratio = AuxTypes.DynamicFloat(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_cost_stamina_ratio(self): if hasattr(self, '_m_has_field_cost_stamina_ratio'): return self._m_has_field_cost_stamina_ratio self._m_has_field_cost_stamina_ratio = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_cost_stamina_ratio', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_skill_id(self): if hasattr(self, '_m_has_field_skill_id'): return self._m_has_field_skill_id self._m_has_field_skill_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skill_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_cd_ratio(self): if hasattr(self, '_m_has_field_cd_ratio'): return self._m_has_field_cd_ratio self._m_has_field_cd_ratio = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_cd_ratio', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class QuestResCollectionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_forbid_delete: self.is_forbid_delete = self._io.read_u1() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_is_forbid_delete(self): if hasattr(self, '_m_has_field_is_forbid_delete'): return self._m_has_field_is_forbid_delete self._m_has_field_is_forbid_delete = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_forbid_delete', None) class SetPartControlTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_part_root_names: self.part_root_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_target_type: self.target_type = Output.EnumControlPartTargetType(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_target_type(self): if hasattr(self, '_m_has_field_target_type'): return self._m_has_field_target_type self._m_has_field_target_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_type', None) @property def has_field_part_root_names(self): if hasattr(self, '_m_has_field_part_root_names'): return self._m_has_field_part_root_names self._m_has_field_part_root_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_part_root_names', None) class ShopRecommendTabTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ForgeUpdateExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TriggerPlayerDie(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ActivityDeliveryWatcherDataConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigActionPanelState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigActionPanelState(self._io, self, self._root)) class ConfigTextMapLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_level_map: self.level_map = Output.DictOfAuxTypesVlqBase128LeSTextMapLevelStruct(self._io, self, self._root) if self.has_field_platform_map: self.platform_map = Output.DictOfEnumTextMapPlatformTypeAuxTypesVlqBase128LeS(self._io, self, self._root) @property def has_field_level_map(self): if hasattr(self, '_m_has_field_level_map'): return self._m_has_field_level_map self._m_has_field_level_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_level_map', None) @property def has_field_platform_map(self): if hasattr(self, '_m_has_field_platform_map'): return self._m_has_field_platform_map self._m_has_field_platform_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_platform_map', None) class SetGlobalValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_random_in_range: self.random_in_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_min_value', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def has_field_random_in_range(self): if hasattr(self, '_m_has_field_random_in_range'): return self._m_has_field_random_in_range self._m_has_field_random_in_range = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_random_in_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringConfigEffectPoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigEffectPoolItem(self._io, self, self._root) class DictOfAuxTypesVlqBase128LeSArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSArrayOfAuxTypesStringLengthU(self._io, self, self._root)) class HitLevelGaugeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_hit_level: self.from_hit_level = Output.EnumHitLevel(self._io, self, self._root) if self.has_field_to_hit_level: self.to_hit_level = Output.EnumHitLevel(self._io, self, self._root) if self.has_field_max_charge: self.max_charge = self._io.read_f4le() if self.has_field_min_charge_delta: self.min_charge_delta = self._io.read_f4le() if self.has_field_max_charge_delta: self.max_charge_delta = self._io.read_f4le() if self.has_field_fade_time: self.fade_time = self._io.read_f4le() @property def has_field_to_hit_level(self): if hasattr(self, '_m_has_field_to_hit_level'): return self._m_has_field_to_hit_level self._m_has_field_to_hit_level = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_to_hit_level', None) @property def has_field_max_charge(self): if hasattr(self, '_m_has_field_max_charge'): return self._m_has_field_max_charge self._m_has_field_max_charge = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_max_charge', None) @property def has_field_max_charge_delta(self): if hasattr(self, '_m_has_field_max_charge_delta'): return self._m_has_field_max_charge_delta self._m_has_field_max_charge_delta = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_max_charge_delta', None) @property def has_field_min_charge_delta(self): if hasattr(self, '_m_has_field_min_charge_delta'): return self._m_has_field_min_charge_delta self._m_has_field_min_charge_delta = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_min_charge_delta', None) @property def has_field_from_hit_level(self): if hasattr(self, '_m_has_field_from_hit_level'): return self._m_has_field_from_hit_level self._m_has_field_from_hit_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_hit_level', None) @property def has_field_fade_time(self): if hasattr(self, '_m_has_field_fade_time'): return self._m_has_field_fade_time self._m_has_field_fade_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_fade_time', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class LevelTagExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_tag_name: self.level_tag_name = AuxTypes.String(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_add_scene_tag_id_list: self.add_scene_tag_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_remove_scene_tag_id_list: self.remove_scene_tag_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_level_tag_can_fix_time: self.level_tag_can_fix_time = self._io.read_u1() if self.has_field_level_tag_fixed_enviro_time: self.level_tag_fixed_enviro_time = self._io.read_f4le() if self.has_field_load_dynamic_group_list: self.load_dynamic_group_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_load_dynamic_group_list(self): if hasattr(self, '_m_has_field_load_dynamic_group_list'): return self._m_has_field_load_dynamic_group_list self._m_has_field_load_dynamic_group_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_load_dynamic_group_list', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_level_tag_fixed_enviro_time(self): if hasattr(self, '_m_has_field_level_tag_fixed_enviro_time'): return self._m_has_field_level_tag_fixed_enviro_time self._m_has_field_level_tag_fixed_enviro_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_level_tag_fixed_enviro_time', None) @property def has_field_level_tag_name(self): if hasattr(self, '_m_has_field_level_tag_name'): return self._m_has_field_level_tag_name self._m_has_field_level_tag_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_tag_name', None) @property def has_field_level_tag_can_fix_time(self): if hasattr(self, '_m_has_field_level_tag_can_fix_time'): return self._m_has_field_level_tag_can_fix_time self._m_has_field_level_tag_can_fix_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_level_tag_can_fix_time', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_remove_scene_tag_id_list(self): if hasattr(self, '_m_has_field_remove_scene_tag_id_list'): return self._m_has_field_remove_scene_tag_id_list self._m_has_field_remove_scene_tag_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_remove_scene_tag_id_list', None) @property def has_field_add_scene_tag_id_list(self): if hasattr(self, '_m_has_field_add_scene_tag_id_list'): return self._m_has_field_add_scene_tag_id_list self._m_has_field_add_scene_tag_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_add_scene_tag_id_list', None) class MechanicusCardEffectExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesStringConfigPlatformUiData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPlatformUiData(self._io, self, self._root) class DictOfAuxTypesStringConfigAttackEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAttackEvent(self._io, self, self._root)) class TalkShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class HuntingRegionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_pos_list: self.center_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_center_radius: self.center_radius = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_safe_clue_group: self.safe_clue_group = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_clue_group: self.clue_group = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_safe_destination_group: self.safe_destination_group = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_destination_group: self.destination_group = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_region_info: self.region_info = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_certain_final_monster_id: self.certain_final_monster_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_center_radius(self): if hasattr(self, '_m_has_field_center_radius'): return self._m_has_field_center_radius self._m_has_field_center_radius = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_center_radius', None) @property def has_field_clue_group(self): if hasattr(self, '_m_has_field_clue_group'): return self._m_has_field_clue_group self._m_has_field_clue_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_clue_group', None) @property def has_field_certain_final_monster_id(self): if hasattr(self, '_m_has_field_certain_final_monster_id'): return self._m_has_field_certain_final_monster_id self._m_has_field_certain_final_monster_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_certain_final_monster_id', None) @property def has_field_safe_clue_group(self): if hasattr(self, '_m_has_field_safe_clue_group'): return self._m_has_field_safe_clue_group self._m_has_field_safe_clue_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_safe_clue_group', None) @property def has_field_destination_group(self): if hasattr(self, '_m_has_field_destination_group'): return self._m_has_field_destination_group self._m_has_field_destination_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_destination_group', None) @property def has_field_center_pos_list(self): if hasattr(self, '_m_has_field_center_pos_list'): return self._m_has_field_center_pos_list self._m_has_field_center_pos_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_center_pos_list', None) @property def has_field_safe_destination_group(self): if hasattr(self, '_m_has_field_safe_destination_group'): return self._m_has_field_safe_destination_group self._m_has_field_safe_destination_group = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_safe_destination_group', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_region_info(self): if hasattr(self, '_m_has_field_region_info'): return self._m_has_field_region_info self._m_has_field_region_info = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_region_info', None) class ConfigPartController(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_parts: self.parts = Output.ArrayOfDispConfigControlPartLengthU(self._io, self, self._root) @property def has_field_parts(self): if hasattr(self, '_m_has_field_parts'): return self._m_has_field_parts self._m_has_field_parts = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_parts', None) class ConfigVMapMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigVBaseMark(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_visible_type_mini_map: self.visible_type_mini_map = Output.EnumMarkVisibleType(self._io, self, self._root) if self.has_field_visible_type_level_map: self.visible_type_level_map = Output.EnumMarkVisibleType(self._io, self, self._root) if self.has_field_layer_type: self.layer_type = Output.EnumMarkLayerType(self._io, self, self._root) @property def has_field_layer_type(self): if hasattr(self, '_m_has_field_layer_type'): return self._m_has_field_layer_type self._m_has_field_layer_type = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_layer_type', None) @property def has_field_visible_type_level_map(self): if hasattr(self, '_m_has_field_visible_type_level_map'): return self._m_has_field_visible_type_level_map self._m_has_field_visible_type_level_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_visible_type_level_map', None) @property def res_path(self): if hasattr(self, '_m_res_path'): return self._m_res_path self._m_res_path = self.base.res_path return getattr(self, '_m_res_path', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def has_field_visible_type_mini_map(self): if hasattr(self, '_m_has_field_visible_type_mini_map'): return self._m_has_field_visible_type_mini_map self._m_has_field_visible_type_mini_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_visible_type_mini_map', None) class TriggerPostProcessEffectMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_post_effect_asset_name: self.post_effect_asset_name = AuxTypes.String(self._io, self, self._root) if self.has_field_duration: self.duration = self._io.read_f4le() if self.has_field_is_stage_effect: self.is_stage_effect = self._io.read_u1() @property def has_field_post_effect_asset_name(self): if hasattr(self, '_m_has_field_post_effect_asset_name'): return self._m_has_field_post_effect_asset_name self._m_has_field_post_effect_asset_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_post_effect_asset_name', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_duration', None) @property def has_field_is_stage_effect(self): if hasattr(self, '_m_has_field_is_stage_effect'): return self._m_has_field_is_stage_effect self._m_has_field_is_stage_effect = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_is_stage_effect', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumAreaTerrainType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.AreaTerrainType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigVehicleSeatLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigVehicleSeat(self._io, self, self._root)) class EnableBulletCollisionPluginTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumUgcAxialType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UgcAxialType, self.data.value) return getattr(self, '_m_value', None) class ConfigHideWidgetPet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_is_hide: self.is_hide = self._io.read_u1() @property def has_field_is_hide(self): if hasattr(self, '_m_has_field_is_hide'): return self._m_has_field_is_hide self._m_has_field_is_hide = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_is_hide', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ConfigAiInvestigateData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_look_around_time: self.look_around_time = self._io.read_f4le() if self.has_field_spacial: self.spacial = self._io.read_u1() @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_look_around_time(self): if hasattr(self, '_m_has_field_look_around_time'): return self._m_has_field_look_around_time self._m_has_field_look_around_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_look_around_time', None) @property def has_field_spacial(self): if hasattr(self, '_m_has_field_spacial'): return self._m_has_field_spacial self._m_has_field_spacial = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_spacial', None) class JudgeEntityInViewResult(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHeightPosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HeightPosType, self.data.value) return getattr(self, '_m_value', None) class EnablePushColliderName(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_push_collider_names: self.push_collider_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_set_enable: self.set_enable = self._io.read_u1() @property def has_field_set_enable(self): if hasattr(self, '_m_has_field_set_enable'): return self._m_has_field_set_enable self._m_has_field_set_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_enable', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_push_collider_names(self): if hasattr(self, '_m_has_field_push_collider_names'): return self._m_has_field_push_collider_names self._m_has_field_push_collider_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_push_collider_names', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class CutsceneExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_path: self.path = AuxTypes.String(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_path(self): if hasattr(self, '_m_has_field_path'): return self._m_has_field_path self._m_has_field_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_path', None) class RegionalPlayVarTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IrodoriMasterLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class QuestCondEx(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_type: self.type = Output.EnumQuestCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class BowDrawTime(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bow_draw_start_norm_time: self.bow_draw_start_norm_time = self._io.read_f4le() if self.has_field_bow_draw_end_norm_time: self.bow_draw_end_norm_time = self._io.read_f4le() if self.has_field_bow_string_override_point: self.bow_string_override_point = AuxTypes.String(self._io, self, self._root) @property def has_field_bow_draw_start_norm_time(self): if hasattr(self, '_m_has_field_bow_draw_start_norm_time'): return self._m_has_field_bow_draw_start_norm_time self._m_has_field_bow_draw_start_norm_time = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bow_draw_start_norm_time', None) @property def has_field_bow_draw_end_norm_time(self): if hasattr(self, '_m_has_field_bow_draw_end_norm_time'): return self._m_has_field_bow_draw_end_norm_time self._m_has_field_bow_draw_end_norm_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_bow_draw_end_norm_time', None) @property def has_field_bow_string_override_point(self): if hasattr(self, '_m_has_field_bow_string_override_point'): return self._m_has_field_bow_string_override_point self._m_has_field_bow_string_override_point = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_bow_string_override_point', None) class ClientSceneTagConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EffigyDifficultyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigBornByTargetLinearPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_linear_offset: self.linear_offset = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_base_on_target: self.base_on_target = self._io.read_u1() if self.has_field_linear_xz: self.linear_xz = self._io.read_u1() if self.has_field_linear_min: self.linear_min = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_linear_max: self.linear_max = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_linear_offset(self): if hasattr(self, '_m_has_field_linear_offset'): return self._m_has_field_linear_offset self._m_has_field_linear_offset = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_linear_offset', None) @property def has_field_linear_xz(self): if hasattr(self, '_m_has_field_linear_xz'): return self._m_has_field_linear_xz self._m_has_field_linear_xz = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_linear_xz', None) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def has_field_linear_min(self): if hasattr(self, '_m_has_field_linear_min'): return self._m_has_field_linear_min self._m_has_field_linear_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_linear_min', None) @property def has_field_linear_max(self): if hasattr(self, '_m_has_field_linear_max'): return self._m_has_field_linear_max self._m_has_field_linear_max = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_linear_max', None) @property def has_field_base_on_target(self): if hasattr(self, '_m_has_field_base_on_target'): return self._m_has_field_base_on_target self._m_has_field_base_on_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_base_on_target', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class EnumTrialAvatarTemplatePlaceholderType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TrialAvatarTemplatePlaceholderType, self.data.value) return getattr(self, '_m_value', None) class ChannellerSlabBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_name: self.buff_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param: self.desc_param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon: self.icon = AuxTypes.String(self._io, self, self._root) if self.has_field_cost: self.cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_quality: self.buff_quality = Output.EnumChannellerSlabBuffQuality(self._io, self, self._root) if self.has_field_buff_quality_type: self.buff_quality_type = Output.EnumQualityType(self._io, self, self._root) @property def has_field_desc_param(self): if hasattr(self, '_m_has_field_desc_param'): return self._m_has_field_desc_param self._m_has_field_desc_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc_param', None) @property def has_field_buff_quality_type(self): if hasattr(self, '_m_has_field_buff_quality_type'): return self._m_has_field_buff_quality_type self._m_has_field_buff_quality_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_buff_quality_type', None) @property def has_field_cost(self): if hasattr(self, '_m_has_field_cost'): return self._m_has_field_cost self._m_has_field_cost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cost', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_buff_name(self): if hasattr(self, '_m_has_field_buff_name'): return self._m_has_field_buff_name self._m_has_field_buff_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_buff_name', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_material_id', None) @property def has_field_icon(self): if hasattr(self, '_m_has_field_icon'): return self._m_has_field_icon self._m_has_field_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_icon', None) @property def has_field_buff_quality(self): if hasattr(self, '_m_has_field_buff_quality'): return self._m_has_field_buff_quality self._m_has_field_buff_quality = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_buff_quality', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class ConfigAiLandingSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAiTacticBaseSetting(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_default_setting: self.default_setting = Output.ConfigAiLandingData(self._io, self, self._root) if self.has_field_specification: self.specification = Output.DictOfAuxTypesVlqBase128LeSConfigAiLandingData(self._io, self, self._root) @property def has_field_specification(self): if hasattr(self, '_m_has_field_specification'): return self._m_has_field_specification self._m_has_field_specification = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_specification', None) @property def condition(self): if hasattr(self, '_m_condition'): return self._m_condition self._m_condition = self.base.condition return getattr(self, '_m_condition', None) @property def nerve_trigger(self): if hasattr(self, '_m_nerve_trigger'): return self._m_nerve_trigger self._m_nerve_trigger = self.base.nerve_trigger return getattr(self, '_m_nerve_trigger', None) @property def enable(self): if hasattr(self, '_m_enable'): return self._m_enable self._m_enable = self.base.enable return getattr(self, '_m_enable', None) @property def has_field_default_setting(self): if hasattr(self, '_m_has_field_default_setting'): return self._m_has_field_default_setting self._m_has_field_default_setting = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_default_setting', None) class ConfigVehicleSeat(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_attach_to: self.attach_to = AuxTypes.String(self._io, self, self._root) if self.has_field_option_id: self.option_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rotate: self.rotate = Output.Vector(self._io, self, self._root) if self.has_field_off_vehicle_up_dist: self.off_vehicle_up_dist = self._io.read_f4le() @property def has_field_attach_to(self): if hasattr(self, '_m_has_field_attach_to'): return self._m_has_field_attach_to self._m_has_field_attach_to = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attach_to', None) @property def has_field_option_id(self): if hasattr(self, '_m_has_field_option_id'): return self._m_has_field_option_id self._m_has_field_option_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_option_id', None) @property def has_field_rotate(self): if hasattr(self, '_m_has_field_rotate'): return self._m_has_field_rotate self._m_has_field_rotate = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_rotate', None) @property def has_field_off_vehicle_up_dist(self): if hasattr(self, '_m_has_field_off_vehicle_up_dist'): return self._m_has_field_off_vehicle_up_dist self._m_has_field_off_vehicle_up_dist = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_off_vehicle_up_dist', None) class ByFollowTargetValid(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_check_component: self.check_component = self._io.read_u1() if self.has_field_check_has_follow_target: self.check_has_follow_target = self._io.read_u1() if self.has_field_check_visible: self.check_visible = self._io.read_u1() if self.has_field_check_active: self.check_active = self._io.read_u1() if self.has_field_check_valid: self.check_valid = self._io.read_u1() @property def has_field_check_visible(self): if hasattr(self, '_m_has_field_check_visible'): return self._m_has_field_check_visible self._m_has_field_check_visible = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_check_visible', None) @property def has_field_check_valid(self): if hasattr(self, '_m_has_field_check_valid'): return self._m_has_field_check_valid self._m_has_field_check_valid = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_check_valid', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_check_has_follow_target(self): if hasattr(self, '_m_has_field_check_has_follow_target'): return self._m_has_field_check_has_follow_target self._m_has_field_check_has_follow_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_check_has_follow_target', None) @property def has_field_check_active(self): if hasattr(self, '_m_has_field_check_active'): return self._m_has_field_check_active self._m_has_field_check_active = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_check_active', None) @property def has_field_check_component(self): if hasattr(self, '_m_has_field_check_component'): return self._m_has_field_check_component self._m_has_field_check_component = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_check_component', None) class SelectActionPointByAllAvatarsOrientation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigActionPointSelectType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_point_i_ds: self.action_point_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_angle: self.angle = self._io.read_f4le() if self.has_field_distance: self.distance = self._io.read_f4le() if self.has_field_sign_type: self.sign_type = self._io.read_u1() @property def has_field_action_point_i_ds(self): if hasattr(self, '_m_has_field_action_point_i_ds'): return self._m_has_field_action_point_i_ds self._m_has_field_action_point_i_ds = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_point_i_ds', None) @property def has_field_angle(self): if hasattr(self, '_m_has_field_angle'): return self._m_has_field_angle self._m_has_field_angle = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_angle', None) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_distance', None) @property def has_field_sign_type(self): if hasattr(self, '_m_has_field_sign_type'): return self._m_has_field_sign_type self._m_has_field_sign_type = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_sign_type', None) class EffigyDifficultyExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SummerTimeV2boatStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumBlossomChestShowType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BlossomChestShowType, self.data.value) return getattr(self, '_m_value', None) class TreasureMapRegionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCoopInteractionGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coop_map: self.coop_map = Output.DictOfAuxTypesVlqBase128LeUDispConfigCoopBaseNode(self._io, self, self._root) if self.has_field_start_node_id: self.start_node_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fail_node_id: self.fail_node_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_id', None) @property def has_field_coop_map(self): if hasattr(self, '_m_has_field_coop_map'): return self._m_has_field_coop_map self._m_has_field_coop_map = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_coop_map', None) @property def has_field_start_node_id(self): if hasattr(self, '_m_has_field_start_node_id'): return self._m_has_field_start_node_id self._m_has_field_start_node_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_start_node_id', None) @property def has_field_fail_node_id(self): if hasattr(self, '_m_has_field_fail_node_id'): return self._m_has_field_fail_node_id self._m_has_field_fail_node_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fail_node_id', None) class ConfigEntityAbilitySystem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_on_being_hit: self.on_being_hit = Output.ArrayOfConfigAbilitySystemLengthU(self._io, self, self._root) @property def has_field_on_being_hit(self): if hasattr(self, '_m_has_field_on_being_hit'): return self._m_has_field_on_being_hit self._m_has_field_on_being_hit = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_on_being_hit', None) class AttachBulletAimPoint(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_bullet_aim_point: self.bullet_aim_point = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_bullet_aim_point(self): if hasattr(self, '_m_has_field_bullet_aim_point'): return self._m_has_field_bullet_aim_point self._m_has_field_bullet_aim_point = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bullet_aim_point', None) class ConfigBornByWorld(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_world_pos: self.world_pos = Output.Vector(self._io, self, self._root) if self.has_field_world_fwd: self.world_fwd = Output.Vector(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def has_field_world_pos(self): if hasattr(self, '_m_has_field_world_pos'): return self._m_has_field_world_pos self._m_has_field_world_pos = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_world_pos', None) @property def has_field_world_fwd(self): if hasattr(self, '_m_has_field_world_fwd'): return self._m_has_field_world_fwd self._m_has_field_world_fwd = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_world_fwd', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class ConfigQteStepBaseInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_inter_action: self.inter_action = Output.DispConfigBaseInterAction(self._io, self, self._root) @property def has_field_inter_action(self): if hasattr(self, '_m_has_field_inter_action'): return self._m_has_field_inter_action self._m_has_field_inter_action = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_inter_action', None) @property def action_type(self): if hasattr(self, '_m_action_type'): return self._m_action_type self._m_action_type = self.base.action_type return getattr(self, '_m_action_type', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) class EnumMoonfinTrialActivityLevelType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MoonfinTrialActivityLevelType, self.data.value) return getattr(self, '_m_value', None) class ParticleEmitLevelTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChargeFillEffectComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GeneralRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHomeWorldLimitShopCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HomeWorldLimitShopCondType, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiCrabMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiCrabMoveData(self._io, self, self._root) class GivingGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_ids: self.item_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_finish_talk_id: self.finish_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mistake_talk_id: self.mistake_talk_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_finish_dialog_id: self.finish_dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_mistake_talk_id(self): if hasattr(self, '_m_has_field_mistake_talk_id'): return self._m_has_field_mistake_talk_id self._m_has_field_mistake_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_mistake_talk_id', None) @property def has_field_finish_talk_id(self): if hasattr(self, '_m_has_field_finish_talk_id'): return self._m_has_field_finish_talk_id self._m_has_field_finish_talk_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_finish_talk_id', None) @property def has_field_item_ids(self): if hasattr(self, '_m_has_field_item_ids'): return self._m_has_field_item_ids self._m_has_field_item_ids = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_ids', None) @property def has_field_finish_dialog_id(self): if hasattr(self, '_m_has_field_finish_dialog_id'): return self._m_has_field_finish_dialog_id self._m_has_field_finish_dialog_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_finish_dialog_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class KvpOfDictAuxTypesStringCustomGadgetNodeSlot(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.CustomGadgetNodeSlot(self._io, self, self._root) class ConfigBornBySelf(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBornType(self._io, self, self._root) @property def on_ground_ignore_water(self): if hasattr(self, '_m_on_ground_ignore_water'): return self._m_on_ground_ignore_water self._m_on_ground_ignore_water = self.base.on_ground_ignore_water return getattr(self, '_m_on_ground_ignore_water', None) @property def born_random(self): if hasattr(self, '_m_born_random'): return self._m_born_random self._m_born_random = self.base.born_random return getattr(self, '_m_born_random', None) @property def along_ground(self): if hasattr(self, '_m_along_ground'): return self._m_along_ground self._m_along_ground = self.base.along_ground return getattr(self, '_m_along_ground', None) @property def on_ground_raycast_up_dist(self): if hasattr(self, '_m_on_ground_raycast_up_dist'): return self._m_on_ground_raycast_up_dist self._m_on_ground_raycast_up_dist = self.base.on_ground_raycast_up_dist return getattr(self, '_m_on_ground_raycast_up_dist', None) @property def use_rotation(self): if hasattr(self, '_m_use_rotation'): return self._m_use_rotation self._m_use_rotation = self.base.use_rotation return getattr(self, '_m_use_rotation', None) @property def direction(self): if hasattr(self, '_m_direction'): return self._m_direction self._m_direction = self.base.direction return getattr(self, '_m_direction', None) @property def on_ground(self): if hasattr(self, '_m_on_ground'): return self._m_on_ground self._m_on_ground = self.base.on_ground return getattr(self, '_m_on_ground', None) @property def offset(self): if hasattr(self, '_m_offset'): return self._m_offset self._m_offset = self.base.offset return getattr(self, '_m_offset', None) class PlayEmoSync(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_dialog_id: self.dialog_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_emo_sync_asset_path: self.emo_sync_asset_path = AuxTypes.String(self._io, self, self._root) @property def has_field_dialog_id(self): if hasattr(self, '_m_has_field_dialog_id'): return self._m_has_field_dialog_id self._m_has_field_dialog_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dialog_id', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_emo_sync_asset_path(self): if hasattr(self, '_m_has_field_emo_sync_asset_path'): return self._m_has_field_emo_sync_asset_path self._m_has_field_emo_sync_asset_path = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_emo_sync_asset_path', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumDropNodeType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.DropNodeType, self.data.value) return getattr(self, '_m_value', None) class MpPlayTextDataExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_mp_play_id: self.mp_play_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest: self.quest = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward: self.reward = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invite: self.invite = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invitedesc: self.invitedesc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_invitedeschost: self.invitedeschost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start: self.start = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_starttip: self.starttip = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_victory: self.victory = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fail: self.fail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_rivive: self.rivive = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_timespend: self.timespend = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_up_avatar_text: self.up_avatar_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_quest(self): if hasattr(self, '_m_has_field_quest'): return self._m_has_field_quest self._m_has_field_quest = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest', None) @property def has_field_reward(self): if hasattr(self, '_m_has_field_reward'): return self._m_has_field_reward self._m_has_field_reward = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_reward', None) @property def has_field_invitedesc(self): if hasattr(self, '_m_has_field_invitedesc'): return self._m_has_field_invitedesc self._m_has_field_invitedesc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_invitedesc', None) @property def has_field_mp_play_id(self): if hasattr(self, '_m_has_field_mp_play_id'): return self._m_has_field_mp_play_id self._m_has_field_mp_play_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_mp_play_id', None) @property def has_field_starttip(self): if hasattr(self, '_m_has_field_starttip'): return self._m_has_field_starttip self._m_has_field_starttip = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_starttip', None) @property def has_field_timespend(self): if hasattr(self, '_m_has_field_timespend'): return self._m_has_field_timespend self._m_has_field_timespend = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_timespend', None) @property def has_field_up_avatar_text(self): if hasattr(self, '_m_has_field_up_avatar_text'): return self._m_has_field_up_avatar_text self._m_has_field_up_avatar_text = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_up_avatar_text', None) @property def has_field_invitedeschost(self): if hasattr(self, '_m_has_field_invitedeschost'): return self._m_has_field_invitedeschost self._m_has_field_invitedeschost = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_invitedeschost', None) @property def has_field_fail(self): if hasattr(self, '_m_has_field_fail'): return self._m_has_field_fail self._m_has_field_fail = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_fail', None) @property def has_field_rivive(self): if hasattr(self, '_m_has_field_rivive'): return self._m_has_field_rivive self._m_has_field_rivive = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_rivive', None) @property def has_field_victory(self): if hasattr(self, '_m_has_field_victory'): return self._m_has_field_victory self._m_has_field_victory = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_victory', None) @property def has_field_invite(self): if hasattr(self, '_m_has_field_invite'): return self._m_has_field_invite self._m_has_field_invite = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_invite', None) @property def has_field_start(self): if hasattr(self, '_m_has_field_start'): return self._m_has_field_start self._m_has_field_start = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_start', None) class EnumBonusActivityState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BonusActivityState, self.data.value) return getattr(self, '_m_value', None) class PointInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_point_id: self.point_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_type: self.point_type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_offset_x: self.offset_x = self._io.read_f4le() if self.has_field_offset_y: self.offset_y = self._io.read_f4le() if self.has_field_offset_z: self.offset_z = self._io.read_f4le() if self.has_field_rot_x: self.rot_x = self._io.read_f4le() if self.has_field_rot_y: self.rot_y = self._io.read_f4le() if self.has_field_rot_z: self.rot_z = self._io.read_f4le() @property def has_field_offset_y(self): if hasattr(self, '_m_has_field_offset_y'): return self._m_has_field_offset_y self._m_has_field_offset_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_offset_y', None) @property def has_field_rot_z(self): if hasattr(self, '_m_has_field_rot_z'): return self._m_has_field_rot_z self._m_has_field_rot_z = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_rot_z', None) @property def has_field_point_id(self): if hasattr(self, '_m_has_field_point_id'): return self._m_has_field_point_id self._m_has_field_point_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_point_id', None) @property def has_field_rot_x(self): if hasattr(self, '_m_has_field_rot_x'): return self._m_has_field_rot_x self._m_has_field_rot_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_rot_x', None) @property def has_field_point_type(self): if hasattr(self, '_m_has_field_point_type'): return self._m_has_field_point_type self._m_has_field_point_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_point_type', None) @property def has_field_offset_x(self): if hasattr(self, '_m_has_field_offset_x'): return self._m_has_field_offset_x self._m_has_field_offset_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_offset_x', None) @property def has_field_offset_z(self): if hasattr(self, '_m_has_field_offset_z'): return self._m_has_field_offset_z self._m_has_field_offset_z = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_offset_z', None) @property def has_field_rot_y(self): if hasattr(self, '_m_has_field_rot_y'): return self._m_has_field_rot_y self._m_has_field_rot_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_rot_y', None) class EnumParamMethod(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ParamMethod, self.data.value) return getattr(self, '_m_value', None) class KvpOfDictAuxTypesStringConfigPerfBoolItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ConfigPerfBoolItem(self._io, self, self._root) class TowerStarReward(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_min_star_count: self.min_star_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_min_star_count(self): if hasattr(self, '_m_has_field_min_star_count'): return self._m_has_field_min_star_count self._m_has_field_min_star_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_min_star_count', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) class MechanicusCardCurseExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effect_id: self.effect_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_last_round: self.last_round = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_param_list: self.desc_param_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_desc_param_list(self): if hasattr(self, '_m_has_field_desc_param_list'): return self._m_has_field_desc_param_list self._m_has_field_desc_param_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc_param_list', None) @property def has_field_effect_id(self): if hasattr(self, '_m_has_field_effect_id'): return self._m_has_field_effect_id self._m_has_field_effect_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_effect_id', None) @property def has_field_last_round(self): if hasattr(self, '_m_has_field_last_round'): return self._m_has_field_last_round self._m_has_field_last_round = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_last_round', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) class MechanicusMapExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityChessMapPointExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_coord_x: self.coord_x = self._io.read_f4le() if self.has_field_coord_y: self.coord_y = self._io.read_f4le() @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_coord_x(self): if hasattr(self, '_m_has_field_coord_x'): return self._m_has_field_coord_x self._m_has_field_coord_x = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_coord_x', None) @property def has_field_coord_y(self): if hasattr(self, '_m_has_field_coord_y'): return self._m_has_field_coord_y self._m_has_field_coord_y = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_coord_y', None) class ArrayOfConfigStateAudioEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigStateAudioEvent(self._io, self, self._root)) class AnimalCodexCountTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ChannellerSlabLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_wave_id: self.wave_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_point_name: self.point_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_camp_name: self.camp_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_preview_reward_id: self.preview_reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_num: self.buff_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_camp_name(self): if hasattr(self, '_m_has_field_camp_name'): return self._m_has_field_camp_name self._m_has_field_camp_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_camp_name', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_point_name(self): if hasattr(self, '_m_has_field_point_name'): return self._m_has_field_point_name self._m_has_field_point_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_point_name', None) @property def has_field_wave_id(self): if hasattr(self, '_m_has_field_wave_id'): return self._m_has_field_wave_id self._m_has_field_wave_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_wave_id', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_buff_num(self): if hasattr(self, '_m_has_field_buff_num'): return self._m_has_field_buff_num self._m_has_field_buff_num = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_buff_num', None) @property def has_field_preview_reward_id(self): if hasattr(self, '_m_has_field_preview_reward_id'): return self._m_has_field_preview_reward_id self._m_has_field_preview_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_preview_reward_id', None) class EchoShellRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FixDvalinS04moveMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumRewardSourceSystemType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RewardSourceSystemType, self.data.value) return getattr(self, '_m_value', None) class ExhibitionDisplayCondParam(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_param_type: self.param_type = Output.EnumExhibitionDisplayCondParamType(self._io, self, self._root) if self.has_field_param: self.param = AuxTypes.String(self._io, self, self._root) @property def has_field_param_type(self): if hasattr(self, '_m_has_field_param_type'): return self._m_has_field_param_type self._m_has_field_param_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param', None) class PlayModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SgvConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = self._io.read_f4le() @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_key', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_value', None) class TileComplexManagerMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_attack_id: self.attack_id = AuxTypes.String(self._io, self, self._root) if self.has_field_interval: self.interval = self._io.read_f4le() if self.has_field_src_camp: self.src_camp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_attack_info: self.attack_info = Output.ConfigAttackInfo(self._io, self, self._root) @property def has_field_attack_info(self): if hasattr(self, '_m_has_field_attack_info'): return self._m_has_field_attack_info self._m_has_field_attack_info = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_attack_info', None) @property def has_field_interval(self): if hasattr(self, '_m_has_field_interval'): return self._m_has_field_interval self._m_has_field_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_interval', None) @property def has_field_src_camp(self): if hasattr(self, '_m_has_field_src_camp'): return self._m_has_field_src_camp self._m_has_field_src_camp = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_src_camp', None) @property def has_field_attack_id(self): if hasattr(self, '_m_has_field_attack_id'): return self._m_has_field_attack_id self._m_has_field_attack_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_attack_id', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumWorldType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WorldType, self.data.value) return getattr(self, '_m_value', None) class MainQuestExcelConfigProxy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ModifierRefJump(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_event_to_jump: self.event_to_jump = AuxTypes.String(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_event_to_jump(self): if hasattr(self, '_m_has_field_event_to_jump'): return self._m_has_field_event_to_jump self._m_has_field_event_to_jump = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_event_to_jump', None) class NewActivityTimeGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id_list: self.group_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_duration: self.duration = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_group_id_list(self): if hasattr(self, '_m_has_field_group_id_list'): return self._m_has_field_group_id_list self._m_has_field_group_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id_list', None) @property def has_field_duration(self): if hasattr(self, '_m_has_field_duration'): return self._m_has_field_duration self._m_has_field_duration = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_duration', None) class CanBeModifiedByComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CaptureAnimal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_material_id: self.material_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_material_id(self): if hasattr(self, '_m_has_field_material_id'): return self._m_has_field_material_id self._m_has_field_material_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_material_id', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class EnumVelocityForceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.VelocityForceType, self.data.value) return getattr(self, '_m_value', None) class BlossomChestShowTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigLevelNpcBornPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigLevelNpcBornPos(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigLevelNpcBornPosNoGroup(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ArrayOfConfigSpatialPortalLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigSpatialPortal(self._io, self, self._root)) class AsterLittleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_id: self.stage_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_next_stage_id_vec: self.next_stage_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_open_day: self.open_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_mission_vec: self.mission_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id_vec: self.watcher_id_vec = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stage_id(self): if hasattr(self, '_m_has_field_stage_id'): return self._m_has_field_stage_id self._m_has_field_stage_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_id', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_watcher_id_vec(self): if hasattr(self, '_m_has_field_watcher_id_vec'): return self._m_has_field_watcher_id_vec self._m_has_field_watcher_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_watcher_id_vec', None) @property def has_field_mission_vec(self): if hasattr(self, '_m_has_field_mission_vec'): return self._m_has_field_mission_vec self._m_has_field_mission_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_mission_vec', None) @property def has_field_open_day(self): if hasattr(self, '_m_has_field_open_day'): return self._m_has_field_open_day self._m_has_field_open_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_open_day', None) @property def has_field_next_stage_id_vec(self): if hasattr(self, '_m_has_field_next_stage_id_vec'): return self._m_has_field_next_stage_id_vec self._m_has_field_next_stage_id_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_next_stage_id_vec', None) class EnumRoguelikeCardLabel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RoguelikeCardLabel, self.data.value) return getattr(self, '_m_value', None) class EntityDisplacementMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_distance: self.trigger_distance = self._io.read_f4le() if self.has_field_action_list: self.action_list = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_trigger_distance(self): if hasattr(self, '_m_has_field_trigger_distance'): return self._m_has_field_trigger_distance self._m_has_field_trigger_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_distance', None) @property def has_field_action_list(self): if hasattr(self, '_m_has_field_action_list'): return self._m_has_field_action_list self._m_has_field_action_list = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_list', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class ConfigMusicGameKey(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_button: self.button = Output.EnumMusicKeyType(self._io, self, self._root) if self.has_field_time: self.time = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_note: self.note = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_is_long_press: self.is_long_press = self._io.read_u1() if self.has_field_long_press_time: self.long_press_time = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_long_press_time(self): if hasattr(self, '_m_has_field_long_press_time'): return self._m_has_field_long_press_time self._m_has_field_long_press_time = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_long_press_time', None) @property def has_field_note(self): if hasattr(self, '_m_has_field_note'): return self._m_has_field_note self._m_has_field_note = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_note', None) @property def has_field_button(self): if hasattr(self, '_m_has_field_button'): return self._m_has_field_button self._m_has_field_button = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_button', None) @property def has_field_is_long_press(self): if hasattr(self, '_m_has_field_is_long_press'): return self._m_has_field_is_long_press self._m_has_field_is_long_press = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_is_long_press', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_time', None) class ChargeBarStyleExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_name: self.icon_name = AuxTypes.String(self._io, self, self._root) if self.has_field_fill_effect_type: self.fill_effect_type = Output.EnumChargeFillEffect(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_icon_name(self): if hasattr(self, '_m_has_field_icon_name'): return self._m_has_field_icon_name self._m_has_field_icon_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_icon_name', None) @property def has_field_fill_effect_type(self): if hasattr(self, '_m_has_field_fill_effect_type'): return self._m_has_field_fill_effect_type self._m_has_field_fill_effect_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_fill_effect_type', None) class ConfigAiSnakelikeMove(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_curvature: self.min_curvature = self._io.read_f4le() if self.has_field_max_curvatrue: self.max_curvatrue = self._io.read_f4le() if self.has_field_min_segment_distance: self.min_segment_distance = self._io.read_f4le() if self.has_field_segment_distance: self.segment_distance = self._io.read_f4le() if self.has_field_segment_count: self.segment_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_segment_distance(self): if hasattr(self, '_m_has_field_segment_distance'): return self._m_has_field_segment_distance self._m_has_field_segment_distance = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_segment_distance', None) @property def has_field_segment_count(self): if hasattr(self, '_m_has_field_segment_count'): return self._m_has_field_segment_count self._m_has_field_segment_count = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_segment_count', None) @property def has_field_min_curvature(self): if hasattr(self, '_m_has_field_min_curvature'): return self._m_has_field_min_curvature self._m_has_field_min_curvature = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_curvature', None) @property def has_field_max_curvatrue(self): if hasattr(self, '_m_has_field_max_curvatrue'): return self._m_has_field_max_curvatrue self._m_has_field_max_curvatrue = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_curvatrue', None) @property def has_field_min_segment_distance(self): if hasattr(self, '_m_has_field_min_segment_distance'): return self._m_has_field_min_segment_distance self._m_has_field_min_segment_distance = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_segment_distance', None) class VelocityForceTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DoTileAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_action_id: self.action_id = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_action_id(self): if hasattr(self, '_m_has_field_action_id'): return self._m_has_field_action_id self._m_has_field_action_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_action_id', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigTriggerOverride(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_override_trigger_flag: self.override_trigger_flag = self._io.read_u1() if self.has_field_trigger_flag: self.trigger_flag = Output.EnumTriggerFlag(self._io, self, self._root) if self.has_field_override_check_count: self.override_check_count = self._io.read_u1() if self.has_field_check_count: self.check_count = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_override_trigger_interval: self.override_trigger_interval = self._io.read_u1() if self.has_field_trigger_interval: self.trigger_interval = self._io.read_f4le() if self.has_field_raw_shape: self.raw_shape = Output.DispConfigBaseShape(self._io, self, self._root) if self.has_field_override_use_local_trigger_logic: self.override_use_local_trigger_logic = self._io.read_u1() if self.has_field_use_local_trigger_logic: self.use_local_trigger_logic = self._io.read_u1() if self.has_field_local_trigger_meta: self.local_trigger_meta = Output.DispConfigLocalTriggerMeta(self._io, self, self._root) @property def has_field_local_trigger_meta(self): if hasattr(self, '_m_has_field_local_trigger_meta'): return self._m_has_field_local_trigger_meta self._m_has_field_local_trigger_meta = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_local_trigger_meta', None) @property def has_field_use_local_trigger_logic(self): if hasattr(self, '_m_has_field_use_local_trigger_logic'): return self._m_has_field_use_local_trigger_logic self._m_has_field_use_local_trigger_logic = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_use_local_trigger_logic', None) @property def has_field_trigger_flag(self): if hasattr(self, '_m_has_field_trigger_flag'): return self._m_has_field_trigger_flag self._m_has_field_trigger_flag = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_trigger_flag', None) @property def has_field_check_count(self): if hasattr(self, '_m_has_field_check_count'): return self._m_has_field_check_count self._m_has_field_check_count = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_check_count', None) @property def has_field_override_trigger_flag(self): if hasattr(self, '_m_has_field_override_trigger_flag'): return self._m_has_field_override_trigger_flag self._m_has_field_override_trigger_flag = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_override_trigger_flag', None) @property def has_field_override_use_local_trigger_logic(self): if hasattr(self, '_m_has_field_override_use_local_trigger_logic'): return self._m_has_field_override_use_local_trigger_logic self._m_has_field_override_use_local_trigger_logic = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_override_use_local_trigger_logic', None) @property def has_field_override_trigger_interval(self): if hasattr(self, '_m_has_field_override_trigger_interval'): return self._m_has_field_override_trigger_interval self._m_has_field_override_trigger_interval = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_override_trigger_interval', None) @property def has_field_trigger_interval(self): if hasattr(self, '_m_has_field_trigger_interval'): return self._m_has_field_trigger_interval self._m_has_field_trigger_interval = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_trigger_interval', None) @property def has_field_raw_shape(self): if hasattr(self, '_m_has_field_raw_shape'): return self._m_has_field_raw_shape self._m_has_field_raw_shape = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_raw_shape', None) @property def has_field_override_check_count(self): if hasattr(self, '_m_has_field_override_check_count'): return self._m_has_field_override_check_count self._m_has_field_override_check_count = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_override_check_count', None) class CoopCondConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumCoopTaskCondType(self._io, self, self._root) if self.has_field_args: self.args = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_args(self): if hasattr(self, '_m_has_field_args'): return self._m_has_field_args self._m_has_field_args = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_args', None) class HeightPosTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfU1ArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictU1ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root)) class ArrayOfArrayOfDispConfigBaseGuideLengthULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ArrayOfDispConfigBaseGuideLengthU(self._io, self, self._root)) class ConfigPolygonZone(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_check_cd: self.check_cd = self._io.read_f4le() @property def has_field_check_cd(self): if hasattr(self, '_m_has_field_check_cd'): return self._m_has_field_check_cd self._m_has_field_check_cd = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_check_cd', None) class EnumFindHilichurlAssignmentType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FindHilichurlAssignmentType, self.data.value) return getattr(self, '_m_value', None) class ConfigGuideAddTaskAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigGuideAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_task_name: self.task_name = AuxTypes.String(self._io, self, self._root) @property def has_field_task_name(self): if hasattr(self, '_m_has_field_task_name'): return self._m_has_field_task_name self._m_has_field_task_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_task_name', None) class ActionEventTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTalkRoleType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TalkRoleType, self.data.value) return getattr(self, '_m_value', None) class TriggerFaceAnimation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_face_animation: self.face_animation = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_face_animation(self): if hasattr(self, '_m_has_field_face_animation'): return self._m_has_field_face_animation self._m_has_field_face_animation = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_face_animation', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class KvpOfDictAuxTypesStringArrayOfAuxTypesVlqBase128LeULengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) class DictOfAuxTypesVlqBase128LeUConfigGadgetTurnState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigGadgetTurnState(self._io, self, self._root)) class ActivitySummerTimeFloatSignalExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TalkCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumQuestCondType(self._io, self, self._root) if self.has_field_param: self.param = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param(self): if hasattr(self, '_m_has_field_param'): return self._m_has_field_param self._m_has_field_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param', None) class EnumBagTab(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BagTab, self.data.value) return getattr(self, '_m_value', None) class OfferingLumenStoneExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_skill: self.desc_skill = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc_detail: self.desc_detail = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_icon_path: self.icon_path = AuxTypes.String(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_desc_skill(self): if hasattr(self, '_m_has_field_desc_skill'): return self._m_has_field_desc_skill self._m_has_field_desc_skill = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc_skill', None) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_icon_path(self): if hasattr(self, '_m_has_field_icon_path'): return self._m_has_field_icon_path self._m_has_field_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_icon_path', None) @property def has_field_desc_detail(self): if hasattr(self, '_m_has_field_desc_detail'): return self._m_has_field_desc_detail self._m_has_field_desc_detail = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc_detail', None) class ConfigGlobalDither(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dither_min_range: self.dither_min_range = self._io.read_f4le() if self.has_field_dither_max_range: self.dither_max_range = self._io.read_f4le() if self.has_field_default_detect_height: self.default_detect_height = self._io.read_f4le() if self.has_field_detect_height_check_step: self.detect_height_check_step = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_dither_min_range(self): if hasattr(self, '_m_has_field_dither_min_range'): return self._m_has_field_dither_min_range self._m_has_field_dither_min_range = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dither_min_range', None) @property def has_field_dither_max_range(self): if hasattr(self, '_m_has_field_dither_max_range'): return self._m_has_field_dither_max_range self._m_has_field_dither_max_range = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_dither_max_range', None) @property def has_field_default_detect_height(self): if hasattr(self, '_m_has_field_default_detect_height'): return self._m_has_field_default_detect_height self._m_has_field_default_detect_height = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_default_detect_height', None) @property def has_field_detect_height_check_step(self): if hasattr(self, '_m_has_field_detect_height_check_step'): return self._m_has_field_detect_height_check_step self._m_has_field_detect_height_check_step = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_detect_height_check_step', None) class EnumBillboardType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.BillboardType, self.data.value) return getattr(self, '_m_value', None) class EnumIndicatorDistanceInfoType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.IndicatorDistanceInfoType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigGadgetConsoleOperationLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetConsoleOperation(self._io, self, self._root)) class AttachModifierToSelfGlobalValueNoInitMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_global_value_key: self.global_value_key = AuxTypes.String(self._io, self, self._root) if self.has_field_add_action: self.add_action = Output.EnumAddActionType(self._io, self, self._root) if self.has_field_value_steps: self.value_steps = Output.ArrayOfAuxTypesDynamicFloatLengthU(self._io, self, self._root) if self.has_field_modifier_name_steps: self.modifier_name_steps = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_action_queues: self.action_queues = Output.ArrayOfArrayOfDispConfigAbilityActionLengthULengthU(self._io, self, self._root) if self.has_field_remove_applied_modifier: self.remove_applied_modifier = self._io.read_u1() @property def has_field_action_queues(self): if hasattr(self, '_m_has_field_action_queues'): return self._m_has_field_action_queues self._m_has_field_action_queues = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_action_queues', None) @property def has_field_value_steps(self): if hasattr(self, '_m_has_field_value_steps'): return self._m_has_field_value_steps self._m_has_field_value_steps = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_value_steps', None) @property def has_field_global_value_key(self): if hasattr(self, '_m_has_field_global_value_key'): return self._m_has_field_global_value_key self._m_has_field_global_value_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_global_value_key', None) @property def has_field_add_action(self): if hasattr(self, '_m_has_field_add_action'): return self._m_has_field_add_action self._m_has_field_add_action = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_add_action', None) @property def has_field_remove_applied_modifier(self): if hasattr(self, '_m_has_field_remove_applied_modifier'): return self._m_has_field_remove_applied_modifier self._m_has_field_remove_applied_modifier = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_remove_applied_modifier', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_modifier_name_steps(self): if hasattr(self, '_m_has_field_modifier_name_steps'): return self._m_has_field_modifier_name_steps self._m_has_field_modifier_name_steps = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_modifier_name_steps', None) class SceneTagCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_cond_type: self.cond_type = Output.EnumSceneTagCondType(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_cond_type(self): if hasattr(self, '_m_has_field_cond_type'): return self._m_has_field_cond_type self._m_has_field_cond_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_cond_type', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2', None) class ConfigPublicAiSkillCd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_min_interval: self.min_interval = self._io.read_f4le() @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_min_interval(self): if hasattr(self, '_m_has_field_min_interval'): return self._m_has_field_min_interval self._m_has_field_min_interval = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_min_interval', None) class OfferingVersionExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DungeonMapAreaExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WinterCampExploreExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class Ps5groupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityAvatarSelectionExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond_id: self.cond_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_avatar_reward_list: self.avatar_reward_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cost_item_id_list: self.cost_item_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_cost_item_num_list: self.cost_item_num_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_blocked: self.is_blocked = self._io.read_u1() @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_is_blocked(self): if hasattr(self, '_m_has_field_is_blocked'): return self._m_has_field_is_blocked self._m_has_field_is_blocked = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_blocked', None) @property def has_field_cond_id(self): if hasattr(self, '_m_has_field_cond_id'): return self._m_has_field_cond_id self._m_has_field_cond_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_cond_id', None) @property def has_field_cost_item_num_list(self): if hasattr(self, '_m_has_field_cost_item_num_list'): return self._m_has_field_cost_item_num_list self._m_has_field_cost_item_num_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cost_item_num_list', None) @property def has_field_cost_item_id_list(self): if hasattr(self, '_m_has_field_cost_item_id_list'): return self._m_has_field_cost_item_id_list self._m_has_field_cost_item_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_cost_item_id_list', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) @property def has_field_avatar_reward_list(self): if hasattr(self, '_m_has_field_avatar_reward_list'): return self._m_has_field_avatar_reward_list self._m_has_field_avatar_reward_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_avatar_reward_list', None) class MainMonsterConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_boss: self.boss = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_monster: self.monster = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_boss(self): if hasattr(self, '_m_has_field_boss'): return self._m_has_field_boss self._m_has_field_boss = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_boss', None) @property def has_field_monster(self): if hasattr(self, '_m_has_field_monster'): return self._m_has_field_monster self._m_has_field_monster = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster', None) class KvpOfDictAuxTypesVlqBase128LeSConfigAiInvestigateData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiInvestigateData(self._io, self, self._root) class FeatureTagExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigExternalVoiceSound(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_source_file_name: self.source_file_name = AuxTypes.String(self._io, self, self._root) if self.has_field_rate: self.rate = self._io.read_f4le() if self.has_field_avatar_name: self.avatar_name = AuxTypes.String(self._io, self, self._root) if self.has_field_emotion: self.emotion = AuxTypes.String(self._io, self, self._root) if self.has_field_gender: self.gender = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_gender(self): if hasattr(self, '_m_has_field_gender'): return self._m_has_field_gender self._m_has_field_gender = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_gender', None) @property def has_field_source_file_name(self): if hasattr(self, '_m_has_field_source_file_name'): return self._m_has_field_source_file_name self._m_has_field_source_file_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_source_file_name', None) @property def has_field_avatar_name(self): if hasattr(self, '_m_has_field_avatar_name'): return self._m_has_field_avatar_name self._m_has_field_avatar_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_avatar_name', None) @property def has_field_emotion(self): if hasattr(self, '_m_has_field_emotion'): return self._m_has_field_emotion self._m_has_field_emotion = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_emotion', None) @property def has_field_rate(self): if hasattr(self, '_m_has_field_rate'): return self._m_has_field_rate self._m_has_field_rate = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_rate', None) class ConfigFootprintEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_effect: self.effect = AuxTypes.String(self._io, self, self._root) if self.has_field_deformation: self.deformation = AuxTypes.String(self._io, self, self._root) @property def has_field_effect(self): if hasattr(self, '_m_has_field_effect'): return self._m_has_field_effect self._m_has_field_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect', None) @property def has_field_deformation(self): if hasattr(self, '_m_has_field_deformation'): return self._m_has_field_deformation self._m_has_field_deformation = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_deformation', None) class ArrayOfAudioWeatherVoTriggerTimeRuleLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioWeatherVoTriggerTimeRule(self._io, self, self._root)) class ServerMessageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_content: self.content = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_show_type: self.show_type = Output.EnumServerMessageShowType(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_content(self): if hasattr(self, '_m_has_field_content'): return self._m_has_field_content self._m_has_field_content = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_content', None) @property def has_field_show_type(self): if hasattr(self, '_m_has_field_show_type'): return self._m_has_field_show_type self._m_has_field_show_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_show_type', None) class ParentQuestStateComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigAiFishingFleeData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_turn_speed_override: self.turn_speed_override = self._io.read_f4le() if self.has_field_flee_angle: self.flee_angle = self._io.read_f4le() if self.has_field_flee_duration: self.flee_duration = self._io.read_f4le() if self.has_field_flee_distance_min: self.flee_distance_min = self._io.read_f4le() if self.has_field_flee_distance_max: self.flee_distance_max = self._io.read_f4le() if self.has_field_turn_to_target: self.turn_to_target = self._io.read_u1() if self.has_field_restricted_by_defend_area: self.restricted_by_defend_area = self._io.read_u1() if self.has_field_expand_flee_angle_when_blocked: self.expand_flee_angle_when_blocked = self._io.read_u1() @property def has_field_restricted_by_defend_area(self): if hasattr(self, '_m_has_field_restricted_by_defend_area'): return self._m_has_field_restricted_by_defend_area self._m_has_field_restricted_by_defend_area = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_restricted_by_defend_area', None) @property def has_field_flee_duration(self): if hasattr(self, '_m_has_field_flee_duration'): return self._m_has_field_flee_duration self._m_has_field_flee_duration = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_flee_duration', None) @property def has_field_flee_angle(self): if hasattr(self, '_m_has_field_flee_angle'): return self._m_has_field_flee_angle self._m_has_field_flee_angle = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_flee_angle', None) @property def has_field_turn_to_target(self): if hasattr(self, '_m_has_field_turn_to_target'): return self._m_has_field_turn_to_target self._m_has_field_turn_to_target = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_turn_to_target', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_flee_distance_max(self): if hasattr(self, '_m_has_field_flee_distance_max'): return self._m_has_field_flee_distance_max self._m_has_field_flee_distance_max = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_flee_distance_max', None) @property def has_field_expand_flee_angle_when_blocked(self): if hasattr(self, '_m_has_field_expand_flee_angle_when_blocked'): return self._m_has_field_expand_flee_angle_when_blocked self._m_has_field_expand_flee_angle_when_blocked = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_expand_flee_angle_when_blocked', None) @property def has_field_flee_distance_min(self): if hasattr(self, '_m_has_field_flee_distance_min'): return self._m_has_field_flee_distance_min self._m_has_field_flee_distance_min = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_flee_distance_min', None) @property def has_field_turn_speed_override(self): if hasattr(self, '_m_has_field_turn_speed_override'): return self._m_has_field_turn_speed_override self._m_has_field_turn_speed_override = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_turn_speed_override', None) class DispConfigVBaseMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigVBaseMark(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigVMapMark(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigVCustomMapMark(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class AddLogicStateValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_logic_state_name: self.logic_state_name = AuxTypes.String(self._io, self, self._root) if self.has_field_value: self.value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_use_limit_range: self.use_limit_range = self._io.read_u1() if self.has_field_max_value: self.max_value = AuxTypes.DynamicFloat(self._io, self, self._root) if self.has_field_min_value: self.min_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_value', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_logic_state_name(self): if hasattr(self, '_m_has_field_logic_state_name'): return self._m_has_field_logic_state_name self._m_has_field_logic_state_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_logic_state_name', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def has_field_value(self): if hasattr(self, '_m_has_field_value'): return self._m_has_field_value self._m_has_field_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_value', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_min_value(self): if hasattr(self, '_m_has_field_min_value'): return self._m_has_field_min_value self._m_has_field_min_value = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_min_value', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_use_limit_range(self): if hasattr(self, '_m_has_field_use_limit_range'): return self._m_has_field_use_limit_range self._m_has_field_use_limit_range = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_use_limit_range', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DictOfAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigWwiseString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeSDictOfAuxTypesVlqBase128LeSConfigWwiseString(self._io, self, self._root)) class CoopTaskCondTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigPerfItemBase(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_category_rating_map: self.category_rating_map = Output.DictOfEnumPerfRatingCategoryArrayOfAuxTypesVlqBase128LeSLengthU(self._io, self, self._root) if self.has_field_player_custom_option: self.player_custom_option = Output.PlayerCustomOptionSetting(self._io, self, self._root) @property def has_field_category_rating_map(self): if hasattr(self, '_m_has_field_category_rating_map'): return self._m_has_field_category_rating_map self._m_has_field_category_rating_map = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_category_rating_map', None) @property def has_field_player_custom_option(self): if hasattr(self, '_m_has_field_player_custom_option'): return self._m_has_field_player_custom_option self._m_has_field_player_custom_option = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_player_custom_option', None) class BaseServerBuffConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_server_buff_id: self.server_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_buff_type: self.server_buff_type = Output.EnumServerBuffType(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_server_buff_id(self): if hasattr(self, '_m_has_field_server_buff_id'): return self._m_has_field_server_buff_id self._m_has_field_server_buff_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_server_buff_id', None) @property def has_field_server_buff_type(self): if hasattr(self, '_m_has_field_server_buff_type'): return self._m_has_field_server_buff_type self._m_has_field_server_buff_type = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_server_buff_type', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_ability_name', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_modifier_name', None) class GivingGroupExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class RogueMonsterPoolExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_difficulty: self.difficulty = Output.EnumRogueMonsterPoolDifficultyType(self._io, self, self._root) if self.has_field_pool_id_list: self.pool_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_difficulty(self): if hasattr(self, '_m_has_field_difficulty'): return self._m_has_field_difficulty self._m_has_field_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_difficulty', None) @property def has_field_pool_id_list(self): if hasattr(self, '_m_has_field_pool_id_list'): return self._m_has_field_pool_id_list self._m_has_field_pool_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pool_id_list', None) class ModifyCameraMaxDistanceMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_max_distance: self.max_distance = self._io.read_f4le() if self.has_field_reset_to_max_on_start: self.reset_to_max_on_start = self._io.read_u1() if self.has_field_lerp_in_duration: self.lerp_in_duration = self._io.read_f4le() if self.has_field_lerp_out_duration: self.lerp_out_duration = self._io.read_f4le() @property def has_field_max_distance(self): if hasattr(self, '_m_has_field_max_distance'): return self._m_has_field_max_distance self._m_has_field_max_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_max_distance', None) @property def has_field_lerp_in_duration(self): if hasattr(self, '_m_has_field_lerp_in_duration'): return self._m_has_field_lerp_in_duration self._m_has_field_lerp_in_duration = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_lerp_in_duration', None) @property def has_field_reset_to_max_on_start(self): if hasattr(self, '_m_has_field_reset_to_max_on_start'): return self._m_has_field_reset_to_max_on_start self._m_has_field_reset_to_max_on_start = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reset_to_max_on_start', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) @property def has_field_lerp_out_duration(self): if hasattr(self, '_m_has_field_lerp_out_duration'): return self._m_has_field_lerp_out_duration self._m_has_field_lerp_out_duration = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_lerp_out_duration', None) class SceneBeHitEffect(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_hit_scene_effect: self.hit_scene_effect = Output.DictOfAuxTypesStringDictOfAuxTypesStringAuxTypesString(self._io, self, self._root) @property def has_field_hit_scene_effect(self): if hasattr(self, '_m_has_field_hit_scene_effect'): return self._m_has_field_hit_scene_effect self._m_has_field_hit_scene_effect = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_hit_scene_effect', None) class EnumGroupKillPolicy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GroupKillPolicy, self.data.value) return getattr(self, '_m_value', None) class SwitchSkillPriorityComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumShopmallRecommendCondType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ShopmallRecommendCondType, self.data.value) return getattr(self, '_m_value', None) class HitBoxTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigContextPattern(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesVlqBase128LeUConfigWidgetGadget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigWidgetGadget(self._io, self, self._root)) class EnumMonsterCategory(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MonsterCategory, self.data.value) return getattr(self, '_m_value', None) class ConfigLevelEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigEntity(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_drop_elem_control_type: self.drop_elem_control_type = Output.EnumDropElemControlType(self._io, self, self._root) if self.has_field_abilities: self.abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_avatar_abilities: self.avatar_abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_team_abilities: self.team_abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_monster_abilities: self.monster_abilities = Output.ArrayOfConfigEntityAbilityEntryLengthU(self._io, self, self._root) if self.has_field_elem_amplify_damage: self.elem_amplify_damage = Output.DictOfAuxTypesStringDictOfAuxTypesStringF4(self._io, self, self._root) if self.has_field_preload_monster_entity_i_ds: self.preload_monster_entity_i_ds = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def common(self): if hasattr(self, '_m_common'): return self._m_common self._m_common = self.base.common return getattr(self, '_m_common', None) @property def has_field_preload_monster_entity_i_ds(self): if hasattr(self, '_m_has_field_preload_monster_entity_i_ds'): return self._m_has_field_preload_monster_entity_i_ds self._m_has_field_preload_monster_entity_i_ds = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_preload_monster_entity_i_ds', None) @property def model(self): if hasattr(self, '_m_model'): return self._m_model self._m_model = self.base.model return getattr(self, '_m_model', None) @property def has_field_drop_elem_control_type(self): if hasattr(self, '_m_has_field_drop_elem_control_type'): return self._m_has_field_drop_elem_control_type self._m_has_field_drop_elem_control_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_drop_elem_control_type', None) @property def dither(self): if hasattr(self, '_m_dither'): return self._m_dither self._m_dither = self.base.dither return getattr(self, '_m_dither', None) @property def has_field_monster_abilities(self): if hasattr(self, '_m_has_field_monster_abilities'): return self._m_has_field_monster_abilities self._m_has_field_monster_abilities = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_monster_abilities', None) @property def has_field_team_abilities(self): if hasattr(self, '_m_has_field_team_abilities'): return self._m_has_field_team_abilities self._m_has_field_team_abilities = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_team_abilities', None) @property def entity_tags(self): if hasattr(self, '_m_entity_tags'): return self._m_entity_tags self._m_entity_tags = self.base.entity_tags return getattr(self, '_m_entity_tags', None) @property def global_value(self): if hasattr(self, '_m_global_value'): return self._m_global_value self._m_global_value = self.base.global_value return getattr(self, '_m_global_value', None) @property def head_control(self): if hasattr(self, '_m_head_control'): return self._m_head_control self._m_head_control = self.base.head_control return getattr(self, '_m_head_control', None) @property def has_field_abilities(self): if hasattr(self, '_m_has_field_abilities'): return self._m_has_field_abilities self._m_has_field_abilities = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_abilities', None) @property def custom_attack_shape(self): if hasattr(self, '_m_custom_attack_shape'): return self._m_custom_attack_shape self._m_custom_attack_shape = self.base.custom_attack_shape return getattr(self, '_m_custom_attack_shape', None) @property def has_field_elem_amplify_damage(self): if hasattr(self, '_m_has_field_elem_amplify_damage'): return self._m_has_field_elem_amplify_damage self._m_has_field_elem_amplify_damage = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_elem_amplify_damage', None) @property def has_field_avatar_abilities(self): if hasattr(self, '_m_has_field_avatar_abilities'): return self._m_has_field_avatar_abilities self._m_has_field_avatar_abilities = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_avatar_abilities', None) @property def special_point(self): if hasattr(self, '_m_special_point'): return self._m_special_point self._m_special_point = self.base.special_point return getattr(self, '_m_special_point', None) class WeatherExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_area_id: self.area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weather_area_id: self.weather_area_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_height_str: self.max_height_str = AuxTypes.String(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_default_valid: self.is_default_valid = self._io.read_u1() if self.has_field_template_name: self.template_name = AuxTypes.String(self._io, self, self._root) if self.has_field_priority: self.priority = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_profile_name: self.profile_name = AuxTypes.String(self._io, self, self._root) if self.has_field_default_climate: self.default_climate = Output.EnumClimateType(self._io, self, self._root) if self.has_field_is_use_default: self.is_use_default = self._io.read_u1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_max_height_str(self): if hasattr(self, '_m_has_field_max_height_str'): return self._m_has_field_max_height_str self._m_has_field_max_height_str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_height_str', None) @property def has_field_area_id(self): if hasattr(self, '_m_has_field_area_id'): return self._m_has_field_area_id self._m_has_field_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_area_id', None) @property def has_field_default_climate(self): if hasattr(self, '_m_has_field_default_climate'): return self._m_has_field_default_climate self._m_has_field_default_climate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_default_climate', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_priority(self): if hasattr(self, '_m_has_field_priority'): return self._m_has_field_priority self._m_has_field_priority = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_priority', None) @property def has_field_is_use_default(self): if hasattr(self, '_m_has_field_is_use_default'): return self._m_has_field_is_use_default self._m_has_field_is_use_default = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_is_use_default', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_weather_area_id(self): if hasattr(self, '_m_has_field_weather_area_id'): return self._m_has_field_weather_area_id self._m_has_field_weather_area_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_weather_area_id', None) @property def has_field_is_default_valid(self): if hasattr(self, '_m_has_field_is_default_valid'): return self._m_has_field_is_default_valid self._m_has_field_is_default_valid = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_default_valid', None) @property def has_field_profile_name(self): if hasattr(self, '_m_has_field_profile_name'): return self._m_has_field_profile_name self._m_has_field_profile_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_profile_name', None) @property def has_field_template_name(self): if hasattr(self, '_m_has_field_template_name'): return self._m_has_field_template_name self._m_has_field_template_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_template_name', None) class CustomGadgetRootExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ScoreStrategy(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_json_path: self.json_path = Output.TokenJsonPath(self._io, self, self._root) if self.has_field_score_rules: self.score_rules = Output.ArrayOfScoreRuleLengthU(self._io, self, self._root) @property def has_field_json_path(self): if hasattr(self, '_m_has_field_json_path'): return self._m_has_field_json_path self._m_has_field_json_path = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_json_path', None) @property def has_field_score_rules(self): if hasattr(self, '_m_has_field_score_rules'): return self._m_has_field_score_rules self._m_has_field_score_rules = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_score_rules', None) class KvpOfDictAuxTypesVlqBase128LeUConfigResourceCollectionContent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.value = Output.ConfigResourceCollectionContent(self._io, self, self._root) class EnumMechanicusCardEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MechanicusCardEffectType, self.data.value) return getattr(self, '_m_value', None) class SignInRewardItemConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_count: self.count = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quality: self.quality = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_item_id', None) @property def has_field_count(self): if hasattr(self, '_m_has_field_count'): return self._m_has_field_count self._m_has_field_count = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_count', None) @property def has_field_quality(self): if hasattr(self, '_m_has_field_quality'): return self._m_has_field_quality self._m_has_field_quality = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_quality', None) class SendEvtElectricCoreMoveInterrupt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DoActionByGainCrystalSeedMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_element_types: self.element_types = Output.ArrayOfEnumElementTypeLengthU(self._io, self, self._root) if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_element_types(self): if hasattr(self, '_m_has_field_element_types'): return self._m_has_field_element_types self._m_has_field_element_types = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_element_types', None) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_actions', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class CaptureExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SourceJumpConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_jump_type: self.jump_type = Output.EnumSourceJumpType(self._io, self, self._root) if self.has_field_jump_param: self.jump_param = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_jump_type(self): if hasattr(self, '_m_has_field_jump_type'): return self._m_has_field_jump_type self._m_has_field_jump_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_jump_type', None) @property def has_field_jump_param(self): if hasattr(self, '_m_has_field_jump_param'): return self._m_has_field_jump_param self._m_has_field_jump_param = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_jump_param', None) class ConfigExternalVoiceLookupItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_file_id: self.file_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_game_trigger: self.game_trigger = Output.EnumAudioVoiceTrigger(self._io, self, self._root) if self.has_field_game_trigger_args: self.game_trigger_args = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_file_id(self): if hasattr(self, '_m_has_field_file_id'): return self._m_has_field_file_id self._m_has_field_file_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_file_id', None) @property def has_field_game_trigger(self): if hasattr(self, '_m_has_field_game_trigger'): return self._m_has_field_game_trigger self._m_has_field_game_trigger = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_game_trigger', None) @property def has_field_game_trigger_args(self): if hasattr(self, '_m_has_field_game_trigger_args'): return self._m_has_field_game_trigger_args self._m_has_field_game_trigger_args = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_game_trigger_args', None) class ConfigQteStepPowerBarComponent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigQteStepBaseComponent(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_init_value: self.init_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_value: self.max_value = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_auto_change_value_per_second: self.auto_change_value_per_second = self._io.read_f4le() if self.has_field_no_input_auto_change_interval: self.no_input_auto_change_interval = self._io.read_f4le() if self.has_field_value_change_trigger: self.value_change_trigger = Output.ArrayOfConfigQteStepCondActionGroupLengthU(self._io, self, self._root) @property def has_field_max_value(self): if hasattr(self, '_m_has_field_max_value'): return self._m_has_field_max_value self._m_has_field_max_value = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_value', None) @property def has_field_no_input_auto_change_interval(self): if hasattr(self, '_m_has_field_no_input_auto_change_interval'): return self._m_has_field_no_input_auto_change_interval self._m_has_field_no_input_auto_change_interval = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_no_input_auto_change_interval', None) @property def has_field_auto_change_value_per_second(self): if hasattr(self, '_m_has_field_auto_change_value_per_second'): return self._m_has_field_auto_change_value_per_second self._m_has_field_auto_change_value_per_second = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_auto_change_value_per_second', None) @property def has_field_value_change_trigger(self): if hasattr(self, '_m_has_field_value_change_trigger'): return self._m_has_field_value_change_trigger self._m_has_field_value_change_trigger = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_value_change_trigger', None) @property def has_field_init_value(self): if hasattr(self, '_m_has_field_init_value'): return self._m_has_field_init_value self._m_has_field_init_value = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_init_value', None) class AvatarLockForwardFlyMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_world_forward: self.world_forward = Output.Vector(self._io, self, self._root) if self.has_field_fly_speed_scale: self.fly_speed_scale = self._io.read_f4le() if self.has_field_fly_back_speed_scale: self.fly_back_speed_scale = self._io.read_f4le() if self.has_field_eular_raw_input: self.eular_raw_input = Output.Vector(self._io, self, self._root) @property def has_field_eular_raw_input(self): if hasattr(self, '_m_has_field_eular_raw_input'): return self._m_has_field_eular_raw_input self._m_has_field_eular_raw_input = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_eular_raw_input', None) @property def has_field_world_forward(self): if hasattr(self, '_m_has_field_world_forward'): return self._m_has_field_world_forward self._m_has_field_world_forward = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_world_forward', None) @property def has_field_fly_speed_scale(self): if hasattr(self, '_m_has_field_fly_speed_scale'): return self._m_has_field_fly_speed_scale self._m_has_field_fly_speed_scale = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fly_speed_scale', None) @property def has_field_fly_back_speed_scale(self): if hasattr(self, '_m_has_field_fly_back_speed_scale'): return self._m_has_field_fly_back_speed_scale self._m_has_field_fly_back_speed_scale = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_fly_back_speed_scale', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumActivityGachaRobotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityGachaRobotType, self.data.value) return getattr(self, '_m_value', None) class FishBaitExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_feature_list: self.feature_list = Output.ArrayOfFishBaitFeatureLengthS(self._io, self, self._root) if self.has_field_sort: self.sort = self._io.read_s1() if self.has_field_pool_id_list: self.pool_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_feature_list(self): if hasattr(self, '_m_has_field_feature_list'): return self._m_has_field_feature_list self._m_has_field_feature_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_feature_list', None) @property def has_field_sort(self): if hasattr(self, '_m_has_field_sort'): return self._m_has_field_sort self._m_has_field_sort = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_sort', None) @property def has_field_pool_id_list(self): if hasattr(self, '_m_has_field_pool_id_list'): return self._m_has_field_pool_id_list self._m_has_field_pool_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_pool_id_list', None) class ProductGoogleGiftCardDetailConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_content_vec: self.content_vec = Output.ArrayOfPackageContentConfigLengthS(self._io, self, self._root) if self.has_field_mail_config_id: self.mail_config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_price_tier: self.price_tier = AuxTypes.String(self._io, self, self._root) if self.has_field_shop_type: self.shop_type = Output.EnumShopType(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) @property def has_field_content_vec(self): if hasattr(self, '_m_has_field_content_vec'): return self._m_has_field_content_vec self._m_has_field_content_vec = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_content_vec', None) @property def has_field_shop_type(self): if hasattr(self, '_m_has_field_shop_type'): return self._m_has_field_shop_type self._m_has_field_shop_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_shop_type', None) @property def has_field_price_tier(self): if hasattr(self, '_m_has_field_price_tier'): return self._m_has_field_price_tier self._m_has_field_price_tier = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_price_tier', None) @property def has_field_mail_config_id(self): if hasattr(self, '_m_has_field_mail_config_id'): return self._m_has_field_mail_config_id self._m_has_field_mail_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_mail_config_id', None) class WorldAreaLevelupConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigEntity(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_common: self.common = Output.ConfigEntityCommon(self._io, self, self._root) if self.has_field_head_control: self.head_control = Output.DispConfigHeadControl(self._io, self, self._root) if self.has_field_special_point: self.special_point = Output.ConfigEntityPoint(self._io, self, self._root) if self.has_field_custom_attack_shape: self.custom_attack_shape = Output.ConfigCustomAttackShape(self._io, self, self._root) if self.has_field_model: self.model = Output.ConfigModel(self._io, self, self._root) if self.has_field_dither: self.dither = Output.ConfigDither(self._io, self, self._root) if self.has_field_global_value: self.global_value = Output.ConfigGlobalValue(self._io, self, self._root) if self.has_field_entity_tags: self.entity_tags = Output.ConfigEntityTags(self._io, self, self._root) @property def has_field_entity_tags(self): if hasattr(self, '_m_has_field_entity_tags'): return self._m_has_field_entity_tags self._m_has_field_entity_tags = (self.bit_field & 128) != 0 return getattr(self, '_m_has_field_entity_tags', None) @property def has_field_custom_attack_shape(self): if hasattr(self, '_m_has_field_custom_attack_shape'): return self._m_has_field_custom_attack_shape self._m_has_field_custom_attack_shape = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_custom_attack_shape', None) @property def has_field_model(self): if hasattr(self, '_m_has_field_model'): return self._m_has_field_model self._m_has_field_model = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_model', None) @property def has_field_common(self): if hasattr(self, '_m_has_field_common'): return self._m_has_field_common self._m_has_field_common = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_common', None) @property def has_field_special_point(self): if hasattr(self, '_m_has_field_special_point'): return self._m_has_field_special_point self._m_has_field_special_point = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_special_point', None) @property def has_field_head_control(self): if hasattr(self, '_m_has_field_head_control'): return self._m_has_field_head_control self._m_has_field_head_control = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_head_control', None) @property def has_field_dither(self): if hasattr(self, '_m_has_field_dither'): return self._m_has_field_dither self._m_has_field_dither = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_dither', None) @property def has_field_global_value(self): if hasattr(self, '_m_has_field_global_value'): return self._m_has_field_global_value self._m_has_field_global_value = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_global_value', None) class TileCampTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigAbilityTask(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigAbilityTask(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigDummyAbilityTask(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigTriggerMassiveElementTask(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ContextConditionChapterQuestVisible(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_chapter_id: self.chapter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_visible: self.visible = self._io.read_u1() @property def has_field_chapter_id(self): if hasattr(self, '_m_has_field_chapter_id'): return self._m_has_field_chapter_id self._m_has_field_chapter_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_chapter_id', None) @property def has_field_visible(self): if hasattr(self, '_m_has_field_visible'): return self._m_has_field_visible self._m_has_field_visible = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_visible', None) class FishSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfDispConfigVBaseMarkLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.DispConfigVBaseMark(self._io, self, self._root)) class ControlPartDoOnUnEnabledComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigGadgetConsoleOperationTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfConfigHomeCommonPosLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeCommonPos(self._io, self, self._root)) class VehicleLimitTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetAnimatorTrigger(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_trigger_id: self.trigger_id = AuxTypes.DynamicString(self._io, self, self._root) if self.has_field_mp_trigger_on_remote: self.mp_trigger_on_remote = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def has_field_mp_trigger_on_remote(self): if hasattr(self, '_m_has_field_mp_trigger_on_remote'): return self._m_has_field_mp_trigger_on_remote self._m_has_field_mp_trigger_on_remote = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_mp_trigger_on_remote', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_trigger_id(self): if hasattr(self, '_m_has_field_trigger_id'): return self._m_has_field_trigger_id self._m_has_field_trigger_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_trigger_id', None) class ConfigAiNetworkSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_sync_skill: self.sync_skill = self._io.read_u1() if self.has_field_reset_hp_on_spawn: self.reset_hp_on_spawn = self._io.read_u1() @property def has_field_sync_skill(self): if hasattr(self, '_m_has_field_sync_skill'): return self._m_has_field_sync_skill self._m_has_field_sync_skill = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_sync_skill', None) @property def has_field_reset_hp_on_spawn(self): if hasattr(self, '_m_has_field_reset_hp_on_spawn'): return self._m_has_field_reset_hp_on_spawn self._m_has_field_reset_hp_on_spawn = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_reset_hp_on_spawn', None) class ConfigCameraSplineCameraPath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCameraSplineBasePath(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_path_points: self.path_points = Output.ArrayOfDispConfigCameraSplineBasePointLengthU(self._io, self, self._root) if self.has_field_fov_curve: self.fov_curve = Output.ConfigAnimationCurve(self._io, self, self._root) @property def has_field_path_points(self): if hasattr(self, '_m_has_field_path_points'): return self._m_has_field_path_points self._m_has_field_path_points = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_path_points', None) @property def has_field_fov_curve(self): if hasattr(self, '_m_has_field_fov_curve'): return self._m_has_field_fov_curve self._m_has_field_fov_curve = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_fov_curve', None) @property def pos_curve(self): if hasattr(self, '_m_pos_curve'): return self._m_pos_curve self._m_pos_curve = self.base.pos_curve return getattr(self, '_m_pos_curve', None) @property def total_length(self): if hasattr(self, '_m_total_length'): return self._m_total_length self._m_total_length = self.base.total_length return getattr(self, '_m_total_length', None) class EnumOpennessFuncType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.OpennessFuncType, self.data.value) return getattr(self, '_m_value', None) class SsaoModeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfEnumVoiceLanguageTypeLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.EnumVoiceLanguageType(self._io, self, self._root)) class HuntingClueTextExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_clue_text_id: self.clue_text_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reminder_id_list: self.reminder_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_clue_text_id(self): if hasattr(self, '_m_has_field_clue_text_id'): return self._m_has_field_clue_text_id self._m_has_field_clue_text_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_clue_text_id', None) @property def has_field_reminder_id_list(self): if hasattr(self, '_m_has_field_reminder_id_list'): return self._m_has_field_reminder_id_list self._m_has_field_reminder_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reminder_id_list', None) class AvatarFlycloakExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class CombatPropertyIndexComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class WatcherTriggerTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TowerBuffConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_tower_buff_list: self.tower_buff_list = Output.ArrayOfTowerBuffLengthU(self._io, self, self._root) @property def has_field_tower_buff_list(self): if hasattr(self, '_m_has_field_tower_buff_list'): return self._m_has_field_tower_buff_list self._m_has_field_tower_buff_list = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_tower_buff_list', None) class RogueDiaryQuestExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_quest_id_list: self.quest_id_list = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_cond_id_list: self.cond_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_watcher_id_list: self.watcher_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_quest_id_list(self): if hasattr(self, '_m_has_field_quest_id_list'): return self._m_has_field_quest_id_list self._m_has_field_quest_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_quest_id_list', None) @property def has_field_cond_id_list(self): if hasattr(self, '_m_has_field_cond_id_list'): return self._m_has_field_cond_id_list self._m_has_field_cond_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_cond_id_list', None) @property def has_field_watcher_id_list(self): if hasattr(self, '_m_has_field_watcher_id_list'): return self._m_has_field_watcher_id_list self._m_has_field_watcher_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_watcher_id_list', None) class EnumTouchInteractType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TouchInteractType, self.data.value) return getattr(self, '_m_value', None) class SamplingData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_mask_table: self.mask_table = Output.ArrayOfDirectionMaskLengthU(self._io, self, self._root) if self.has_field_data: self.data = Output.ArrayOfLayeredSamplingDataLengthU(self._io, self, self._root) @property def has_field_mask_table(self): if hasattr(self, '_m_has_field_mask_table'): return self._m_has_field_mask_table self._m_has_field_mask_table = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_mask_table', None) @property def has_field_data(self): if hasattr(self, '_m_has_field_data'): return self._m_has_field_data self._m_has_field_data = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_data', None) class RogueMonsterPoolExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSConfigAiCombatFixedMoveData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.ConfigAiCombatFixedMoveData(self._io, self, self._root) class BartenderMaterialUnlockConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_day: self.unlock_day = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_recipe_page_order: self.recipe_page_order = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_unlock_day(self): if hasattr(self, '_m_has_field_unlock_day'): return self._m_has_field_unlock_day self._m_has_field_unlock_day = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_day', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_weight', None) @property def has_field_recipe_page_order(self): if hasattr(self, '_m_has_field_recipe_page_order'): return self._m_has_field_recipe_page_order self._m_has_field_recipe_page_order = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_recipe_page_order', None) class DictOfAuxTypesStringDictOfAuxTypesStringAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDictOfAuxTypesStringAuxTypesString(self._io, self, self._root)) class ConfigPickup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_pick_type: self.pick_type = Output.EnumPickType(self._io, self, self._root) if self.has_field_is_static: self.is_static = self._io.read_u1() if self.has_field_drop_point_max_yaw: self.drop_point_max_yaw = self._io.read_f4le() if self.has_field_drop_point_min_speed: self.drop_point_min_speed = self._io.read_f4le() if self.has_field_drop_point_max_speed: self.drop_point_max_speed = self._io.read_f4le() if self.has_field_born_effect: self.born_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_effect: self.drop_effect = AuxTypes.String(self._io, self, self._root) if self.has_field_drop_offset: self.drop_offset = Output.Vector(self._io, self, self._root) if self.has_field_enable_scan: self.enable_scan = self._io.read_u1() if self.has_field_lock_ymove: self.lock_ymove = self._io.read_u1() if self.has_field_suspend_height: self.suspend_height = self._io.read_f4le() if self.has_field_suspend_speed: self.suspend_speed = self._io.read_f4le() if self.has_field_suspend_amplitude: self.suspend_amplitude = self._io.read_f4le() if self.has_field_rotate_speed: self.rotate_speed = self._io.read_f4le() if self.has_field_rotate_vec: self.rotate_vec = Output.Vector(self._io, self, self._root) if self.has_field_attract_delay_time: self.attract_delay_time = self._io.read_f4le() if self.has_field_multi: self.multi = Output.ConfigPickupMulti(self._io, self, self._root) if self.has_field_dir_vec: self.dir_vec = Output.Vector(self._io, self, self._root) if self.has_field_gravity_ration: self.gravity_ration = self._io.read_f4le() if self.has_field_disable_init_jump: self.disable_init_jump = self._io.read_u1() if self.has_field_init_back_speed: self.init_back_speed = self._io.read_f4le() if self.has_field_back_decelerate: self.back_decelerate = self._io.read_f4le() if self.has_field_back_fan_angle: self.back_fan_angle = self._io.read_f4le() if self.has_field_back_fan_start_angle: self.back_fan_start_angle = self._io.read_f4le() if self.has_field_rebound_times: self.rebound_times = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_rebound_ration: self.rebound_ration = self._io.read_f4le() if self.has_field_attract_accelerate: self.attract_accelerate = self._io.read_f4le() if self.has_field_attract_max_distance: self.attract_max_distance = self._io.read_f4le() if self.has_field_height_offset: self.height_offset = self._io.read_f4le() if self.has_field_rotate_decelerate: self.rotate_decelerate = Output.Vector(self._io, self, self._root) if self.has_field_attract_audio: self.attract_audio = AuxTypes.String(self._io, self, self._root) if self.has_field_is_dummy_pick: self.is_dummy_pick = self._io.read_u1() if self.has_field_is_pick_destroy: self.is_pick_destroy = self._io.read_u1() @property def has_field_back_fan_angle(self): if hasattr(self, '_m_has_field_back_fan_angle'): return self._m_has_field_back_fan_angle self._m_has_field_back_fan_angle = (self.bit_field.value & 4194304) != 0 return getattr(self, '_m_has_field_back_fan_angle', None) @property def has_field_rebound_times(self): if hasattr(self, '_m_has_field_rebound_times'): return self._m_has_field_rebound_times self._m_has_field_rebound_times = (self.bit_field.value & 16777216) != 0 return getattr(self, '_m_has_field_rebound_times', None) @property def has_field_suspend_amplitude(self): if hasattr(self, '_m_has_field_suspend_amplitude'): return self._m_has_field_suspend_amplitude self._m_has_field_suspend_amplitude = (self.bit_field.value & 4096) != 0 return getattr(self, '_m_has_field_suspend_amplitude', None) @property def has_field_suspend_height(self): if hasattr(self, '_m_has_field_suspend_height'): return self._m_has_field_suspend_height self._m_has_field_suspend_height = (self.bit_field.value & 1024) != 0 return getattr(self, '_m_has_field_suspend_height', None) @property def has_field_drop_point_max_speed(self): if hasattr(self, '_m_has_field_drop_point_max_speed'): return self._m_has_field_drop_point_max_speed self._m_has_field_drop_point_max_speed = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_drop_point_max_speed', None) @property def has_field_attract_accelerate(self): if hasattr(self, '_m_has_field_attract_accelerate'): return self._m_has_field_attract_accelerate self._m_has_field_attract_accelerate = (self.bit_field.value & 67108864) != 0 return getattr(self, '_m_has_field_attract_accelerate', None) @property def has_field_attract_delay_time(self): if hasattr(self, '_m_has_field_attract_delay_time'): return self._m_has_field_attract_delay_time self._m_has_field_attract_delay_time = (self.bit_field.value & 32768) != 0 return getattr(self, '_m_has_field_attract_delay_time', None) @property def has_field_pick_type(self): if hasattr(self, '_m_has_field_pick_type'): return self._m_has_field_pick_type self._m_has_field_pick_type = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_pick_type', None) @property def has_field_init_back_speed(self): if hasattr(self, '_m_has_field_init_back_speed'): return self._m_has_field_init_back_speed self._m_has_field_init_back_speed = (self.bit_field.value & 1048576) != 0 return getattr(self, '_m_has_field_init_back_speed', None) @property def has_field_drop_point_min_speed(self): if hasattr(self, '_m_has_field_drop_point_min_speed'): return self._m_has_field_drop_point_min_speed self._m_has_field_drop_point_min_speed = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_drop_point_min_speed', None) @property def has_field_drop_offset(self): if hasattr(self, '_m_has_field_drop_offset'): return self._m_has_field_drop_offset self._m_has_field_drop_offset = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_drop_offset', None) @property def has_field_is_static(self): if hasattr(self, '_m_has_field_is_static'): return self._m_has_field_is_static self._m_has_field_is_static = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_is_static', None) @property def has_field_height_offset(self): if hasattr(self, '_m_has_field_height_offset'): return self._m_has_field_height_offset self._m_has_field_height_offset = (self.bit_field.value & 268435456) != 0 return getattr(self, '_m_has_field_height_offset', None) @property def has_field_is_dummy_pick(self): if hasattr(self, '_m_has_field_is_dummy_pick'): return self._m_has_field_is_dummy_pick self._m_has_field_is_dummy_pick = (self.bit_field.value & 2147483648) != 0 return getattr(self, '_m_has_field_is_dummy_pick', None) @property def has_field_is_pick_destroy(self): if hasattr(self, '_m_has_field_is_pick_destroy'): return self._m_has_field_is_pick_destroy self._m_has_field_is_pick_destroy = (self.bit_field.value & 4294967296) != 0 return getattr(self, '_m_has_field_is_pick_destroy', None) @property def has_field_disable_init_jump(self): if hasattr(self, '_m_has_field_disable_init_jump'): return self._m_has_field_disable_init_jump self._m_has_field_disable_init_jump = (self.bit_field.value & 524288) != 0 return getattr(self, '_m_has_field_disable_init_jump', None) @property def has_field_born_effect(self): if hasattr(self, '_m_has_field_born_effect'): return self._m_has_field_born_effect self._m_has_field_born_effect = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_born_effect', None) @property def has_field_lock_ymove(self): if hasattr(self, '_m_has_field_lock_ymove'): return self._m_has_field_lock_ymove self._m_has_field_lock_ymove = (self.bit_field.value & 512) != 0 return getattr(self, '_m_has_field_lock_ymove', None) @property def has_field_back_fan_start_angle(self): if hasattr(self, '_m_has_field_back_fan_start_angle'): return self._m_has_field_back_fan_start_angle self._m_has_field_back_fan_start_angle = (self.bit_field.value & 8388608) != 0 return getattr(self, '_m_has_field_back_fan_start_angle', None) @property def has_field_drop_effect(self): if hasattr(self, '_m_has_field_drop_effect'): return self._m_has_field_drop_effect self._m_has_field_drop_effect = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_drop_effect', None) @property def has_field_rotate_speed(self): if hasattr(self, '_m_has_field_rotate_speed'): return self._m_has_field_rotate_speed self._m_has_field_rotate_speed = (self.bit_field.value & 8192) != 0 return getattr(self, '_m_has_field_rotate_speed', None) @property def has_field_suspend_speed(self): if hasattr(self, '_m_has_field_suspend_speed'): return self._m_has_field_suspend_speed self._m_has_field_suspend_speed = (self.bit_field.value & 2048) != 0 return getattr(self, '_m_has_field_suspend_speed', None) @property def has_field_back_decelerate(self): if hasattr(self, '_m_has_field_back_decelerate'): return self._m_has_field_back_decelerate self._m_has_field_back_decelerate = (self.bit_field.value & 2097152) != 0 return getattr(self, '_m_has_field_back_decelerate', None) @property def has_field_rebound_ration(self): if hasattr(self, '_m_has_field_rebound_ration'): return self._m_has_field_rebound_ration self._m_has_field_rebound_ration = (self.bit_field.value & 33554432) != 0 return getattr(self, '_m_has_field_rebound_ration', None) @property def has_field_attract_max_distance(self): if hasattr(self, '_m_has_field_attract_max_distance'): return self._m_has_field_attract_max_distance self._m_has_field_attract_max_distance = (self.bit_field.value & 134217728) != 0 return getattr(self, '_m_has_field_attract_max_distance', None) @property def has_field_multi(self): if hasattr(self, '_m_has_field_multi'): return self._m_has_field_multi self._m_has_field_multi = (self.bit_field.value & 65536) != 0 return getattr(self, '_m_has_field_multi', None) @property def has_field_attract_audio(self): if hasattr(self, '_m_has_field_attract_audio'): return self._m_has_field_attract_audio self._m_has_field_attract_audio = (self.bit_field.value & 1073741824) != 0 return getattr(self, '_m_has_field_attract_audio', None) @property def has_field_gravity_ration(self): if hasattr(self, '_m_has_field_gravity_ration'): return self._m_has_field_gravity_ration self._m_has_field_gravity_ration = (self.bit_field.value & 262144) != 0 return getattr(self, '_m_has_field_gravity_ration', None) @property def has_field_rotate_decelerate(self): if hasattr(self, '_m_has_field_rotate_decelerate'): return self._m_has_field_rotate_decelerate self._m_has_field_rotate_decelerate = (self.bit_field.value & 536870912) != 0 return getattr(self, '_m_has_field_rotate_decelerate', None) @property def has_field_rotate_vec(self): if hasattr(self, '_m_has_field_rotate_vec'): return self._m_has_field_rotate_vec self._m_has_field_rotate_vec = (self.bit_field.value & 16384) != 0 return getattr(self, '_m_has_field_rotate_vec', None) @property def has_field_dir_vec(self): if hasattr(self, '_m_has_field_dir_vec'): return self._m_has_field_dir_vec self._m_has_field_dir_vec = (self.bit_field.value & 131072) != 0 return getattr(self, '_m_has_field_dir_vec', None) @property def has_field_enable_scan(self): if hasattr(self, '_m_has_field_enable_scan'): return self._m_has_field_enable_scan self._m_has_field_enable_scan = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_enable_scan', None) @property def has_field_drop_point_max_yaw(self): if hasattr(self, '_m_has_field_drop_point_max_yaw'): return self._m_has_field_drop_point_max_yaw self._m_has_field_drop_point_max_yaw = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_drop_point_max_yaw', None) class GlobalValueChangeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DieStateFlagComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigDialogGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigDialogGroup(self._io, self, self._root) elif _on == 4: self.data = Output.ConfigActivityDialogGroup(self._io, self, self._root) elif _on == 6: self.data = Output.ConfigGadgetDialogGroup(self._io, self, self._root) elif _on == 7: self.data = Output.ConfigNpcOtherDialogGroup(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigFreeDialogGroup(self._io, self, self._root) elif _on == 3: self.data = Output.ConfigBlossomDialogGroup(self._io, self, self._root) elif _on == 5: self.data = Output.ConfigCoopDialogGroup(self._io, self, self._root) elif _on == 8: self.data = Output.ConfigCutsceneDialogGroup(self._io, self, self._root) elif _on == 2: self.data = Output.ConfigNarratorDialogGroup(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ArrayOfConfigEntityAbilityEntryLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigEntityAbilityEntry(self._io, self, self._root)) class ConfigAiExtractionData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_speed_level: self.speed_level = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_extraction_distance: self.extraction_distance = self._io.read_f4le() if self.has_field_extraction_angle_max: self.extraction_angle_max = self._io.read_f4le() if self.has_field_extraction_angle_min: self.extraction_angle_min = self._io.read_f4le() if self.has_field_trigger_distance: self.trigger_distance = self._io.read_f4le() if self.has_field_kill_self_time: self.kill_self_time = self._io.read_f4le() @property def has_field_extraction_angle_max(self): if hasattr(self, '_m_has_field_extraction_angle_max'): return self._m_has_field_extraction_angle_max self._m_has_field_extraction_angle_max = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_extraction_angle_max', None) @property def has_field_extraction_angle_min(self): if hasattr(self, '_m_has_field_extraction_angle_min'): return self._m_has_field_extraction_angle_min self._m_has_field_extraction_angle_min = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_extraction_angle_min', None) @property def has_field_trigger_distance(self): if hasattr(self, '_m_has_field_trigger_distance'): return self._m_has_field_trigger_distance self._m_has_field_trigger_distance = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_trigger_distance', None) @property def has_field_speed_level(self): if hasattr(self, '_m_has_field_speed_level'): return self._m_has_field_speed_level self._m_has_field_speed_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_speed_level', None) @property def has_field_extraction_distance(self): if hasattr(self, '_m_has_field_extraction_distance'): return self._m_has_field_extraction_distance self._m_has_field_extraction_distance = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_extraction_distance', None) @property def has_field_kill_self_time(self): if hasattr(self, '_m_has_field_kill_self_time'): return self._m_has_field_kill_self_time self._m_has_field_kill_self_time = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_kill_self_time', None) class EndureTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MainQuestExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EchoShellFloatSignalExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_config_id', None) class ArrayOfConfigLevelBlockMetaLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigLevelBlockMeta(self._io, self, self._root)) class ReunionSignInExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class TowerBuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_tower_buff_id: self.tower_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_lasting_type: self.lasting_type = Output.EnumTowerBuffLastingType(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_buff_icon: self.buff_icon = AuxTypes.String(self._io, self, self._root) if self.has_field_buff_id: self.buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_buff_icon(self): if hasattr(self, '_m_has_field_buff_icon'): return self._m_has_field_buff_icon self._m_has_field_buff_icon = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_buff_icon', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_buff_id(self): if hasattr(self, '_m_has_field_buff_id'): return self._m_has_field_buff_id self._m_has_field_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_buff_id', None) @property def has_field_tower_buff_id(self): if hasattr(self, '_m_has_field_tower_buff_id'): return self._m_has_field_tower_buff_id self._m_has_field_tower_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_tower_buff_id', None) @property def has_field_lasting_type(self): if hasattr(self, '_m_has_field_lasting_type'): return self._m_has_field_lasting_type self._m_has_field_lasting_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_lasting_type', None) class ConfigCameraShakeExt(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_infinity: self.infinity = self._io.read_u1() if self.has_field_base_on_camera: self.base_on_camera = self._io.read_u1() if self.has_field_after_shake: self.after_shake = self._io.read_u1() if self.has_field_base_cycle: self.base_cycle = self._io.read_f4le() if self.has_field_cycle_damping: self.cycle_damping = self._io.read_f4le() if self.has_field_range_attenuation: self.range_attenuation = self._io.read_f4le() @property def has_field_base_cycle(self): if hasattr(self, '_m_has_field_base_cycle'): return self._m_has_field_base_cycle self._m_has_field_base_cycle = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_base_cycle', None) @property def has_field_cycle_damping(self): if hasattr(self, '_m_has_field_cycle_damping'): return self._m_has_field_cycle_damping self._m_has_field_cycle_damping = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_cycle_damping', None) @property def has_field_after_shake(self): if hasattr(self, '_m_has_field_after_shake'): return self._m_has_field_after_shake self._m_has_field_after_shake = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_after_shake', None) @property def has_field_infinity(self): if hasattr(self, '_m_has_field_infinity'): return self._m_has_field_infinity self._m_has_field_infinity = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_infinity', None) @property def has_field_base_on_camera(self): if hasattr(self, '_m_has_field_base_on_camera'): return self._m_has_field_base_on_camera self._m_has_field_base_on_camera = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_base_on_camera', None) @property def has_field_range_attenuation(self): if hasattr(self, '_m_has_field_range_attenuation'): return self._m_has_field_range_attenuation self._m_has_field_range_attenuation = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_range_attenuation', None) class ConfigAudioPlayAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_audio_event_str: self.audio_event_str = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def has_field_audio_event_str(self): if hasattr(self, '_m_has_field_audio_event_str'): return self._m_has_field_audio_event_str self._m_has_field_audio_event_str = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_audio_event_str', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ArrayOfAudioImpactOverrideEventLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.AudioImpactOverrideEvent(self._io, self, self._root)) class RqTalkExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AvatarLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_exp: self.exp = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_small_talent_point: self.small_talent_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_exp(self): if hasattr(self, '_m_has_field_exp'): return self._m_has_field_exp self._m_has_field_exp = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_exp', None) @property def has_field_small_talent_point(self): if hasattr(self, '_m_has_field_small_talent_point'): return self._m_has_field_small_talent_point self._m_has_field_small_talent_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_small_talent_point', None) class MpPlayerSettleSyncTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumPerfOptionTextType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PerfOptionTextType, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigHomeworldDjinnInfoDefaultSaveLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigHomeworldDjinnInfoDefaultSave(self._io, self, self._root)) class TargetRegisterTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumHitLevel(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.HitLevel, self.data.value) return getattr(self, '_m_value', None) class EnumLanV2projectionMotionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LanV2projectionMotionType, self.data.value) return getattr(self, '_m_value', None) class PhotographPosenameExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class KvpOfDictAuxTypesVlqBase128LeSOutputSetting(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.VlqBase128LeS(self._io, self, self._root) self.value = Output.OutputSetting(self._io, self, self._root) class ConfigWidgetToyCamera(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseWidgetToy(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_camera_id: self.camera_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def tags(self): if hasattr(self, '_m_tags'): return self._m_tags self._m_tags = self.base.tags return getattr(self, '_m_tags', None) @property def is_consume_material(self): if hasattr(self, '_m_is_consume_material'): return self._m_is_consume_material self._m_is_consume_material = self.base.is_consume_material return getattr(self, '_m_is_consume_material', None) @property def has_field_camera_id(self): if hasattr(self, '_m_has_field_camera_id'): return self._m_has_field_camera_id self._m_has_field_camera_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_camera_id', None) @property def business_type(self): if hasattr(self, '_m_business_type'): return self._m_business_type self._m_business_type = self.base.business_type return getattr(self, '_m_business_type', None) @property def cd_group(self): if hasattr(self, '_m_cd_group'): return self._m_cd_group self._m_cd_group = self.base.cd_group return getattr(self, '_m_cd_group', None) class ConfigCameraSplineBasePath(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_pos_curve: self.pos_curve = Output.ConfigAnimationCurve(self._io, self, self._root) if self.has_field_total_length: self.total_length = self._io.read_f4le() @property def has_field_pos_curve(self): if hasattr(self, '_m_has_field_pos_curve'): return self._m_has_field_pos_curve self._m_has_field_pos_curve = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_pos_curve', None) @property def has_field_total_length(self): if hasattr(self, '_m_has_field_total_length'): return self._m_has_field_total_length self._m_has_field_total_length = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_total_length', None) class ConfigSkipUnindexedEffectCreation(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_skip_unindexed_effect_creation_by_distance: self.skip_unindexed_effect_creation_by_distance = Output.ConfigSkipUnindexedEffectCreationByDistance(self._io, self, self._root) @property def has_field_skip_unindexed_effect_creation_by_distance(self): if hasattr(self, '_m_has_field_skip_unindexed_effect_creation_by_distance'): return self._m_has_field_skip_unindexed_effect_creation_by_distance self._m_has_field_skip_unindexed_effect_creation_by_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_skip_unindexed_effect_creation_by_distance', None) class MoonfinTrialActivityLevelTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumLifeState(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.LifeState, self.data.value) return getattr(self, '_m_value', None) class EnumMainPageUiDisableType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MainPageUiDisableType, self.data.value) return getattr(self, '_m_value', None) class EnumMichiaeMatsuriRadarMarkType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.MichiaeMatsuriRadarMarkType, self.data.value) return getattr(self, '_m_value', None) class EnumActorBornRelativePosType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActorBornRelativePosType, self.data.value) return getattr(self, '_m_value', None) class ActivityChessGearExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_gear_id: self.gear_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_name: self.gear_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_short_name: self.gear_short_name = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gear_icon_path: self.gear_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_tag_icon_path: self.tag_icon_path = AuxTypes.String(self._io, self, self._root) if self.has_field_attack: self.attack = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_mastery: self.mastery = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_attack_speed: self.attack_speed = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_attack_range: self.attack_range = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_build_cost: self.build_cost = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_demolition_refund: self.demolition_refund = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_gadget_id: self.gadget_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_build_limit: self.build_limit = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_ban_dungeon_list: self.ban_dungeon_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_enable_rotate: self.is_enable_rotate = self._io.read_u1() if self.has_field_init_level: self.init_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_need_chess_level: self.need_chess_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_need_chess_level(self): if hasattr(self, '_m_has_field_need_chess_level'): return self._m_has_field_need_chess_level self._m_has_field_need_chess_level = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 2) != 0)) return getattr(self, '_m_has_field_need_chess_level', None) @property def has_field_is_enable_rotate(self): if hasattr(self, '_m_has_field_is_enable_rotate'): return self._m_has_field_is_enable_rotate self._m_has_field_is_enable_rotate = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 128) != 0)) return getattr(self, '_m_has_field_is_enable_rotate', None) @property def has_field_attack_speed(self): if hasattr(self, '_m_has_field_attack_speed'): return self._m_has_field_attack_speed self._m_has_field_attack_speed = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_attack_speed', None) @property def has_field_attack(self): if hasattr(self, '_m_has_field_attack'): return self._m_has_field_attack self._m_has_field_attack = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_attack', None) @property def has_field_demolition_refund(self): if hasattr(self, '_m_has_field_demolition_refund'): return self._m_has_field_demolition_refund self._m_has_field_demolition_refund = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_demolition_refund', None) @property def has_field_build_cost(self): if hasattr(self, '_m_has_field_build_cost'): return self._m_has_field_build_cost self._m_has_field_build_cost = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_build_cost', None) @property def has_field_attack_range(self): if hasattr(self, '_m_has_field_attack_range'): return self._m_has_field_attack_range self._m_has_field_attack_range = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_attack_range', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_gear_name(self): if hasattr(self, '_m_has_field_gear_name'): return self._m_has_field_gear_name self._m_has_field_gear_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_gear_name', None) @property def has_field_gadget_id(self): if hasattr(self, '_m_has_field_gadget_id'): return self._m_has_field_gadget_id self._m_has_field_gadget_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_gadget_id', None) @property def has_field_gear_short_name(self): if hasattr(self, '_m_has_field_gear_short_name'): return self._m_has_field_gear_short_name self._m_has_field_gear_short_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_gear_short_name', None) @property def has_field_build_limit(self): if hasattr(self, '_m_has_field_build_limit'): return self._m_has_field_build_limit self._m_has_field_build_limit = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_build_limit', None) @property def has_field_gear_icon_path(self): if hasattr(self, '_m_has_field_gear_icon_path'): return self._m_has_field_gear_icon_path self._m_has_field_gear_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_gear_icon_path', None) @property def has_field_init_level(self): if hasattr(self, '_m_has_field_init_level'): return self._m_has_field_init_level self._m_has_field_init_level = ((self.bit_field.length.value >= (2 + 1)) and ((self.bit_field.bitfield[2] & 1) != 0)) return getattr(self, '_m_has_field_init_level', None) @property def has_field_mastery(self): if hasattr(self, '_m_has_field_mastery'): return self._m_has_field_mastery self._m_has_field_mastery = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_mastery', None) @property def has_field_tag_icon_path(self): if hasattr(self, '_m_has_field_tag_icon_path'): return self._m_has_field_tag_icon_path self._m_has_field_tag_icon_path = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_tag_icon_path', None) @property def has_field_gear_id(self): if hasattr(self, '_m_has_field_gear_id'): return self._m_has_field_gear_id self._m_has_field_gear_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_gear_id', None) @property def has_field_ban_dungeon_list(self): if hasattr(self, '_m_has_field_ban_dungeon_list'): return self._m_has_field_ban_dungeon_list self._m_has_field_ban_dungeon_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_ban_dungeon_list', None) class ChannellerSlabBuffCostExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumTrialFetterConditionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.TrialFetterConditionType, self.data.value) return getattr(self, '_m_value', None) class ByTargetOverrideMapValue(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.RelationalOperationPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_target_ability_name: self.target_ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_target_key: self.target_key = AuxTypes.String(self._io, self, self._root) if self.has_field_target_value: self.target_value = AuxTypes.DynamicFloat(self._io, self, self._root) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def logic(self): if hasattr(self, '_m_logic'): return self._m_logic self._m_logic = self.base.logic return getattr(self, '_m_logic', None) @property def has_field_target_key(self): if hasattr(self, '_m_has_field_target_key'): return self._m_has_field_target_key self._m_has_field_target_key = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_key', None) @property def has_field_target_ability_name(self): if hasattr(self, '_m_has_field_target_ability_name'): return self._m_has_field_target_ability_name self._m_has_field_target_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_target_ability_name', None) @property def has_field_target_value(self): if hasattr(self, '_m_has_field_target_value'): return self._m_has_field_target_value self._m_has_field_target_value = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_target_value', None) class DictOfAuxTypesVlqBase128LeUConfigPreload(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesVlqBase128LeUConfigPreload(self._io, self, self._root)) class GalleryTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class GadgetCameraBoxUiActionTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ContextConditionAnd(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_conditions: self.conditions = Output.ArrayOfDispContextConditionLengthU(self._io, self, self._root) @property def has_field_conditions(self): if hasattr(self, '_m_has_field_conditions'): return self._m_has_field_conditions self._m_has_field_conditions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_conditions', None) class ChannellerSlabDungeonExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DigOverAllExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByBigTeamHasBodyType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_body_type: self.body_type = AuxTypes.String(self._io, self, self._root) if self.has_field_number: self.number = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_logic: self.logic = Output.EnumRelationalOperator(self._io, self, self._root) @property def has_field_body_type(self): if hasattr(self, '_m_has_field_body_type'): return self._m_has_field_body_type self._m_has_field_body_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_body_type', None) @property def has_field_number(self): if hasattr(self, '_m_has_field_number'): return self._m_has_field_number self._m_has_field_number = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_number', None) @property def has_field_logic(self): if hasattr(self, '_m_has_field_logic'): return self._m_has_field_logic self._m_has_field_logic = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_logic', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class MpPlayAbilityGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_index', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_avatar_id', None) class CombatBillboardSizeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumCustomGadgetNodeSlotType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CustomGadgetNodeSlotType, self.data.value) return getattr(self, '_m_value', None) class ConfigOverrideGroup(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringDispConfigBaseStateLayer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringDispConfigBaseStateLayer(self._io, self, self._root)) class EnumCoopActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CoopActionType, self.data.value) return getattr(self, '_m_value', None) class MultistageExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stage_type: self.stage_type = AuxTypes.String(self._io, self, self._root) if self.has_field_is_main_group_can_unload: self.is_main_group_can_unload = self._io.read_u1() @property def has_field_stage_type(self): if hasattr(self, '_m_has_field_stage_type'): return self._m_has_field_stage_type self._m_has_field_stage_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stage_type', None) @property def has_field_is_main_group_can_unload(self): if hasattr(self, '_m_has_field_is_main_group_can_unload'): return self._m_has_field_is_main_group_can_unload self._m_has_field_is_main_group_can_unload = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_main_group_can_unload', None) class ConfigCustomLevelDungeon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_dungeon_id: self.dungeon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_start_room_id: self.start_room_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_room_list: self.room_list = Output.ArrayOfConfigCustomLevelRoomSettingLengthU(self._io, self, self._root) @property def has_field_dungeon_id(self): if hasattr(self, '_m_has_field_dungeon_id'): return self._m_has_field_dungeon_id self._m_has_field_dungeon_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_dungeon_id', None) @property def has_field_start_room_id(self): if hasattr(self, '_m_has_field_start_room_id'): return self._m_has_field_start_room_id self._m_has_field_start_room_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_start_room_id', None) @property def has_field_room_list(self): if hasattr(self, '_m_has_field_room_list'): return self._m_has_field_room_list self._m_has_field_room_list = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_room_list', None) class FettersExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_is_hiden: self.is_hiden = self._io.read_u1() if self.has_field_hide_costume_list: self.hide_costume_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_show_costume_list: self.show_costume_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_tips: self.tips = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_voice_title: self.voice_title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_file: self.voice_file = AuxTypes.String(self._io, self, self._root) if self.has_field_voice_file_text: self.voice_file_text = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_voice_title_locked: self.voice_title_locked = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_fetter_id: self.fetter_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_open_conds: self.open_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) if self.has_field_finish_conds: self.finish_conds = Output.ArrayOfFetterConditionConfigLengthS(self._io, self, self._root) @property def has_field_voice_title_locked(self): if hasattr(self, '_m_has_field_voice_title_locked'): return self._m_has_field_voice_title_locked self._m_has_field_voice_title_locked = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_voice_title_locked', None) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_hide_costume_list(self): if hasattr(self, '_m_has_field_hide_costume_list'): return self._m_has_field_hide_costume_list self._m_has_field_hide_costume_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_hide_costume_list', None) @property def has_field_show_costume_list(self): if hasattr(self, '_m_has_field_show_costume_list'): return self._m_has_field_show_costume_list self._m_has_field_show_costume_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_show_costume_list', None) @property def has_field_voice_file_text(self): if hasattr(self, '_m_has_field_voice_file_text'): return self._m_has_field_voice_file_text self._m_has_field_voice_file_text = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_voice_file_text', None) @property def has_field_voice_file(self): if hasattr(self, '_m_has_field_voice_file'): return self._m_has_field_voice_file self._m_has_field_voice_file = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_voice_file', None) @property def has_field_voice_title(self): if hasattr(self, '_m_has_field_voice_title'): return self._m_has_field_voice_title self._m_has_field_voice_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_voice_title', None) @property def has_field_open_conds(self): if hasattr(self, '_m_has_field_open_conds'): return self._m_has_field_open_conds self._m_has_field_open_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_open_conds', None) @property def has_field_fetter_id(self): if hasattr(self, '_m_has_field_fetter_id'): return self._m_has_field_fetter_id self._m_has_field_fetter_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_fetter_id', None) @property def has_field_tips(self): if hasattr(self, '_m_has_field_tips'): return self._m_has_field_tips self._m_has_field_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_tips', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_finish_conds(self): if hasattr(self, '_m_has_field_finish_conds'): return self._m_has_field_finish_conds self._m_has_field_finish_conds = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_finish_conds', None) @property def has_field_is_hiden(self): if hasattr(self, '_m_has_field_is_hiden'): return self._m_has_field_is_hiden self._m_has_field_is_hiden = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_is_hiden', None) class SyncToStageScript(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_alias: self.alias = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_alias(self): if hasattr(self, '_m_has_field_alias'): return self._m_has_field_alias self._m_has_field_alias = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_alias', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class IndicatorConditionAvatarDistance(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.IndicatorCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_distance: self.distance = Output.TemplateParamFloat(self._io, self, self._root) @property def has_field_distance(self): if hasattr(self, '_m_has_field_distance'): return self._m_has_field_distance self._m_has_field_distance = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_distance', None) class WeaponEnhanceRuleTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnablePartControl(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_part_root_names: self.part_root_names = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_part_root_names(self): if hasattr(self, '_m_has_field_part_root_names'): return self._m_has_field_part_root_names self._m_has_field_part_root_names = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_part_root_names', None) class ExecuteGadgetLua(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_param3: self.param3 = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def has_field_param3(self): if hasattr(self, '_m_has_field_param3'): return self._m_has_field_param3 self._m_has_field_param3 = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_param3', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_param2', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_param1', None) class ConfigRequestMsgAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_msg_name: self.msg_name = AuxTypes.String(self._io, self, self._root) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_msg_name(self): if hasattr(self, '_m_has_field_msg_name'): return self._m_has_field_msg_name self._m_has_field_msg_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_msg_name', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class ContextActionCreateQuestAcceptionMark(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_config_id: self.config_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_config_id(self): if hasattr(self, '_m_has_field_config_id'): return self._m_has_field_config_id self._m_has_field_config_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_config_id', None) class EnumExhibitionListDisplayType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ExhibitionListDisplayType, self.data.value) return getattr(self, '_m_value', None) class FishStockLimit(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_stock_type: self.stock_type = Output.EnumFishStockType(self._io, self, self._root) if self.has_field_min_num: self.min_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_num: self.max_num = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_stock_type(self): if hasattr(self, '_m_has_field_stock_type'): return self._m_has_field_stock_type self._m_has_field_stock_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_stock_type', None) @property def has_field_min_num(self): if hasattr(self, '_m_has_field_min_num'): return self._m_has_field_min_num self._m_has_field_min_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_min_num', None) @property def has_field_max_num(self): if hasattr(self, '_m_has_field_max_num'): return self._m_has_field_max_num self._m_has_field_max_num = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_num', None) class ServerBuffTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigSpatialPortal(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_position: self.position = Output.Vector(self._io, self, self._root) if self.has_field_rotation: self.rotation = Output.Vector(self._io, self, self._root) if self.has_field_size: self.size = Output.Vector(self._io, self, self._root) if self.has_field_enabled: self.enabled = self._io.read_u1() if self.has_field_front_room_name: self.front_room_name = AuxTypes.String(self._io, self, self._root) if self.has_field_back_room_name: self.back_room_name = AuxTypes.String(self._io, self, self._root) @property def has_field_rotation(self): if hasattr(self, '_m_has_field_rotation'): return self._m_has_field_rotation self._m_has_field_rotation = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_rotation', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_name', None) @property def has_field_back_room_name(self): if hasattr(self, '_m_has_field_back_room_name'): return self._m_has_field_back_room_name self._m_has_field_back_room_name = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_back_room_name', None) @property def has_field_position(self): if hasattr(self, '_m_has_field_position'): return self._m_has_field_position self._m_has_field_position = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_position', None) @property def has_field_size(self): if hasattr(self, '_m_has_field_size'): return self._m_has_field_size self._m_has_field_size = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_size', None) @property def has_field_enabled(self): if hasattr(self, '_m_has_field_enabled'): return self._m_has_field_enabled self._m_has_field_enabled = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_enabled', None) @property def has_field_front_room_name(self): if hasattr(self, '_m_has_field_front_room_name'): return self._m_has_field_front_room_name self._m_has_field_front_room_name = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_front_room_name', None) class ConfigTalentMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumElementReactionSourceType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ElementReactionSourceType, self.data.value) return getattr(self, '_m_value', None) class ConfigCoopCondNode(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigCoopBaseNode(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_coop_cond_grp: self.coop_cond_grp = Output.CoopCondGroup(self._io, self, self._root) @property def has_field_coop_cond_grp(self): if hasattr(self, '_m_has_field_coop_cond_grp'): return self._m_has_field_coop_cond_grp self._m_has_field_coop_cond_grp = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_coop_cond_grp', None) @property def coop_node_id(self): if hasattr(self, '_m_coop_node_id'): return self._m_coop_node_id self._m_coop_node_id = self.base.coop_node_id return getattr(self, '_m_coop_node_id', None) @property def coop_node_type(self): if hasattr(self, '_m_coop_node_type'): return self._m_coop_node_type self._m_coop_node_type = self.base.coop_node_type return getattr(self, '_m_coop_node_type', None) @property def next_node_array(self): if hasattr(self, '_m_next_node_array'): return self._m_next_node_array self._m_next_node_array = self.base.next_node_array return getattr(self, '_m_next_node_array', None) class FatherChallengePropertyComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class IntIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityAbilityGroupExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_index: self.index = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_avatar_id: self.avatar_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weapon_id: self.weapon_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_avatar_id(self): if hasattr(self, '_m_has_field_avatar_id'): return self._m_has_field_avatar_id self._m_has_field_avatar_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_avatar_id', None) @property def has_field_weapon_id(self): if hasattr(self, '_m_has_field_weapon_id'): return self._m_has_field_weapon_id self._m_has_field_weapon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_weapon_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_index(self): if hasattr(self, '_m_has_field_index'): return self._m_has_field_index self._m_has_field_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_index', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) class LampProgressControlConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_hour: self.hour = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_min_progress: self.min_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_max_progress: self.max_progress = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_hour(self): if hasattr(self, '_m_has_field_hour'): return self._m_has_field_hour self._m_has_field_hour = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_hour', None) @property def has_field_min_progress(self): if hasattr(self, '_m_has_field_min_progress'): return self._m_has_field_min_progress self._m_has_field_min_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_min_progress', None) @property def has_field_max_progress(self): if hasattr(self, '_m_has_field_max_progress'): return self._m_has_field_max_progress self._m_has_field_max_progress = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_max_progress', None) class CustomLevelComponentLimitConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MaterialCodexTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class NewActivityScoreRewardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringArrayOfElementConvertToChargeBarValueMixinItemLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringArrayOfElementConvertToChargeBarValueMixinItemLengthU(self._io, self, self._root)) class EnumActivityBannerUiElementType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ActivityBannerUiElementType, self.data.value) return getattr(self, '_m_value', None) class BattlePassLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_level_up_need_point: self.level_up_need_point = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_level_up_need_point(self): if hasattr(self, '_m_has_field_level_up_need_point'): return self._m_has_field_level_up_need_point self._m_has_field_level_up_need_point = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_level_up_need_point', None) class HuntingClueMonsterExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigIgnoreCollision(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_self_colliders: self.self_colliders = Output.ArrayOfConfigEntityColliderLengthU(self._io, self, self._root) if self.has_field_target_colliders: self.target_colliders = Output.ArrayOfConfigEntityColliderLengthU(self._io, self, self._root) @property def has_field_self_colliders(self): if hasattr(self, '_m_has_field_self_colliders'): return self._m_has_field_self_colliders self._m_has_field_self_colliders = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_self_colliders', None) @property def has_field_target_colliders(self): if hasattr(self, '_m_has_field_target_colliders'): return self._m_has_field_target_colliders self._m_has_field_target_colliders = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_target_colliders', None) class DungeonSerialConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DebugBoardInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.DebugBlletinInfo(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_type: self.type = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.String(self._io, self, self._root) if self.has_field_location: self.location = AuxTypes.String(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_title', None) @property def content(self): if hasattr(self, '_m_content'): return self._m_content self._m_content = self.base.content return getattr(self, '_m_content', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_scene_id', None) @property def board_id(self): if hasattr(self, '_m_board_id'): return self._m_board_id self._m_board_id = self.base.board_id return getattr(self, '_m_board_id', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_type', None) @property def id(self): if hasattr(self, '_m_id'): return self._m_id self._m_id = self.base.id return getattr(self, '_m_id', None) @property def create_time(self): if hasattr(self, '_m_create_time'): return self._m_create_time self._m_create_time = self.base.create_time return getattr(self, '_m_create_time', None) @property def author(self): if hasattr(self, '_m_author'): return self._m_author self._m_author = self.base.author return getattr(self, '_m_author', None) @property def has_field_location(self): if hasattr(self, '_m_has_field_location'): return self._m_has_field_location self._m_has_field_location = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_location', None) class EnumGalleryType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GalleryType, self.data.value) return getattr(self, '_m_value', None) class AchievementGoalExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EntityMarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ClearGlobalPos(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_key: self.key = AuxTypes.String(self._io, self, self._root) if self.has_field_set_target: self.set_target = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def has_field_set_target(self): if hasattr(self, '_m_has_field_set_target'): return self._m_has_field_set_target self._m_has_field_set_target = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_set_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_key(self): if hasattr(self, '_m_has_field_key'): return self._m_has_field_key self._m_has_field_key = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_key', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ShopmallRecommendCond(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumShopmallRecommendCondType(self._io, self, self._root) if self.has_field_param1str: self.param1str = AuxTypes.String(self._io, self, self._root) if self.has_field_param2str: self.param2str = AuxTypes.String(self._io, self, self._root) if self.has_field_param1: self.param1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_param2: self.param2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_param2str(self): if hasattr(self, '_m_has_field_param2str'): return self._m_has_field_param2str self._m_has_field_param2str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_param2str', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_param2(self): if hasattr(self, '_m_has_field_param2'): return self._m_has_field_param2 self._m_has_field_param2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_param2', None) @property def has_field_param1(self): if hasattr(self, '_m_has_field_param1'): return self._m_has_field_param1 self._m_has_field_param1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_param1', None) @property def has_field_param1str(self): if hasattr(self, '_m_has_field_param1str'): return self._m_has_field_param1str self._m_has_field_param1str = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_param1str', None) class ActivityArenaChallengePreviewExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_schedule_id: self.schedule_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_center_pos_list: self.center_pos_list = Output.ArrayOfF4LengthU(self._io, self, self._root) if self.has_field_guide_main_quest_id: self.guide_main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_side_quest_id: self.guide_side_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_guide_quest_id1: self.guide_quest_id1 = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_guide_quest_id1(self): if hasattr(self, '_m_has_field_guide_quest_id1'): return self._m_has_field_guide_quest_id1 self._m_has_field_guide_quest_id1 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_guide_quest_id1', None) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_schedule_id(self): if hasattr(self, '_m_has_field_schedule_id'): return self._m_has_field_schedule_id self._m_has_field_schedule_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_schedule_id', None) @property def has_field_guide_side_quest_id(self): if hasattr(self, '_m_has_field_guide_side_quest_id'): return self._m_has_field_guide_side_quest_id self._m_has_field_guide_side_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_guide_side_quest_id', None) @property def has_field_center_pos_list(self): if hasattr(self, '_m_has_field_center_pos_list'): return self._m_has_field_center_pos_list self._m_has_field_center_pos_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_center_pos_list', None) @property def has_field_guide_main_quest_id(self): if hasattr(self, '_m_has_field_guide_main_quest_id'): return self._m_has_field_guide_main_quest_id self._m_has_field_guide_main_quest_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_guide_main_quest_id', None) class DungeonEntryExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dungeon_entry_id: self.dungeon_entry_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_type: self.type = Output.EnumDungunEntryType(self._io, self, self._root) if self.has_field_is_show_in_adv_handbook: self.is_show_in_adv_handbook = self._io.read_u1() if self.has_field_desc: self.desc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cooldown_tips_dungeon_id: self.cooldown_tips_dungeon_id = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_is_default_open: self.is_default_open = self._io.read_u1() if self.has_field_is_daily_refresh: self.is_daily_refresh = self._io.read_u1() if self.has_field_cond_comb: self.cond_comb = Output.EnumLogicType(self._io, self, self._root) if self.has_field_satisfied_cond: self.satisfied_cond = Output.ArrayOfDungeonEntrySatisfiedCondLengthS(self._io, self, self._root) if self.has_field_pic_path: self.pic_path = AuxTypes.String(self._io, self, self._root) if self.has_field_system_open_ui_id: self.system_open_ui_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_data_id: self.reward_data_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_description_cycle_reward_list: self.description_cycle_reward_list = Output.ArrayOfArrayOfAuxTypesVlqBase128LeULengthULengthU(self._io, self, self._root) @property def has_field_pic_path(self): if hasattr(self, '_m_has_field_pic_path'): return self._m_has_field_pic_path self._m_has_field_pic_path = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_pic_path', None) @property def has_field_is_default_open(self): if hasattr(self, '_m_has_field_is_default_open'): return self._m_has_field_is_default_open self._m_has_field_is_default_open = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_is_default_open', None) @property def has_field_cooldown_tips_dungeon_id(self): if hasattr(self, '_m_has_field_cooldown_tips_dungeon_id'): return self._m_has_field_cooldown_tips_dungeon_id self._m_has_field_cooldown_tips_dungeon_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_cooldown_tips_dungeon_id', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_is_daily_refresh(self): if hasattr(self, '_m_has_field_is_daily_refresh'): return self._m_has_field_is_daily_refresh self._m_has_field_is_daily_refresh = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_is_daily_refresh', None) @property def has_field_cond_comb(self): if hasattr(self, '_m_has_field_cond_comb'): return self._m_has_field_cond_comb self._m_has_field_cond_comb = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_cond_comb', None) @property def has_field_type(self): if hasattr(self, '_m_has_field_type'): return self._m_has_field_type self._m_has_field_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_type', None) @property def has_field_system_open_ui_id(self): if hasattr(self, '_m_has_field_system_open_ui_id'): return self._m_has_field_system_open_ui_id self._m_has_field_system_open_ui_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_system_open_ui_id', None) @property def has_field_satisfied_cond(self): if hasattr(self, '_m_has_field_satisfied_cond'): return self._m_has_field_satisfied_cond self._m_has_field_satisfied_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_satisfied_cond', None) @property def has_field_dungeon_entry_id(self): if hasattr(self, '_m_has_field_dungeon_entry_id'): return self._m_has_field_dungeon_entry_id self._m_has_field_dungeon_entry_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_dungeon_entry_id', None) @property def has_field_description_cycle_reward_list(self): if hasattr(self, '_m_has_field_description_cycle_reward_list'): return self._m_has_field_description_cycle_reward_list self._m_has_field_description_cycle_reward_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 64) != 0)) return getattr(self, '_m_has_field_description_cycle_reward_list', None) @property def has_field_is_show_in_adv_handbook(self): if hasattr(self, '_m_has_field_is_show_in_adv_handbook'): return self._m_has_field_is_show_in_adv_handbook self._m_has_field_is_show_in_adv_handbook = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_is_show_in_adv_handbook', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_reward_data_id(self): if hasattr(self, '_m_has_field_reward_data_id'): return self._m_has_field_reward_data_id self._m_has_field_reward_data_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_reward_data_id', None) class ShowUiCombatBar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_show: self.show = self._io.read_u1() if self.has_field_sort_id: self.sort_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_changing_sort_id: self.changing_sort_id = self._io.read_u1() if self.has_field_fore: self.fore = self._io.read_u1() @property def has_field_sort_id(self): if hasattr(self, '_m_has_field_sort_id'): return self._m_has_field_sort_id self._m_has_field_sort_id = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_sort_id', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_show(self): if hasattr(self, '_m_has_field_show'): return self._m_has_field_show self._m_has_field_show = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_show', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_changing_sort_id(self): if hasattr(self, '_m_has_field_changing_sort_id'): return self._m_has_field_changing_sort_id self._m_has_field_changing_sort_id = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_changing_sort_id', None) @property def has_field_fore(self): if hasattr(self, '_m_has_field_fore'): return self._m_has_field_fore self._m_has_field_fore = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_fore', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class FloatIndexSerializer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ResetClimateMeter(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_climate_type: self.climate_type = Output.EnumJsonClimateType(self._io, self, self._root) @property def has_field_climate_type(self): if hasattr(self, '_m_has_field_climate_type'): return self._m_has_field_climate_type self._m_has_field_climate_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_climate_type', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class TriggerDropEquipParts(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_drop_all: self.drop_all = self._io.read_u1() if self.has_field_equip_parts: self.equip_parts = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) @property def has_field_equip_parts(self): if hasattr(self, '_m_has_field_equip_parts'): return self._m_has_field_equip_parts self._m_has_field_equip_parts = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_equip_parts', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_drop_all(self): if hasattr(self, '_m_has_field_drop_all'): return self._m_has_field_drop_all self._m_has_field_drop_all = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_drop_all', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigPolygonArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_min_area: self.min_area = Output.Vector(self._io, self, self._root) if self.has_field_max_area: self.max_area = Output.Vector(self._io, self, self._root) if self.has_field_road_points: self.road_points = Output.ArrayOfVectorLengthU(self._io, self, self._root) @property def has_field_min_area(self): if hasattr(self, '_m_has_field_min_area'): return self._m_has_field_min_area self._m_has_field_min_area = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_min_area', None) @property def has_field_max_area(self): if hasattr(self, '_m_has_field_max_area'): return self._m_has_field_max_area self._m_has_field_max_area = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_max_area', None) @property def has_field_road_points(self): if hasattr(self, '_m_has_field_road_points'): return self._m_has_field_road_points self._m_has_field_road_points = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_road_points', None) class DungeonRosterConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ArrayOfFetterConditionConfigLengthS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.FetterConditionConfig(self._io, self, self._root)) class TextLanguageTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigMutiPlatformUiData(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_multi_platform: self.multi_platform = Output.DictOfAuxTypesStringConfigPlatformUiData(self._io, self, self._root) @property def has_field_multi_platform(self): if hasattr(self, '_m_has_field_multi_platform'): return self._m_has_field_multi_platform self._m_has_field_multi_platform = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_multi_platform', None) class EnumGrowCurveType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GrowCurveType, self.data.value) return getattr(self, '_m_value', None) class EnumRogueDiaryBuffEffectType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.RogueDiaryBuffEffectType, self.data.value) return getattr(self, '_m_value', None) class GroupLinksBundleExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigCustomAttackCircle(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_custom_attack_circle_radius: self.custom_attack_circle_radius = self._io.read_f4le() if self.has_field_custom_attack_circle_inner_radius: self.custom_attack_circle_inner_radius = self._io.read_f4le() @property def has_field_custom_attack_circle_radius(self): if hasattr(self, '_m_has_field_custom_attack_circle_radius'): return self._m_has_field_custom_attack_circle_radius self._m_has_field_custom_attack_circle_radius = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_custom_attack_circle_radius', None) @property def has_field_custom_attack_circle_inner_radius(self): if hasattr(self, '_m_has_field_custom_attack_circle_inner_radius'): return self._m_has_field_custom_attack_circle_inner_radius self._m_has_field_custom_attack_circle_inner_radius = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_custom_attack_circle_inner_radius', None) class ConfigAudioAmbience(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_effective_scene_ids: self.effective_scene_ids = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_relative_positions: self.relative_positions = Output.ArrayOfVectorLengthU(self._io, self, self._root) if self.has_field_positioned_events: self.positioned_events = Output.ArrayOfAudioAmbiencePositionedEventLengthU(self._io, self, self._root) if self.has_field_tree_info: self.tree_info = Output.ConfigAudioTreeInfo(self._io, self, self._root) if self.has_field_dynamic_ray_info: self.dynamic_ray_info = Output.ConfigAudioDynamicRayInfo(self._io, self, self._root) if self.has_field_area2d_info: self.area2d_info = Output.ConfigAudioArea2dInfo(self._io, self, self._root) if self.has_field_height_rtpc_key: self.height_rtpc_key = Output.ConfigWwiseString(self._io, self, self._root) if self.has_field_using_adaptive_openness_detection: self.using_adaptive_openness_detection = self._io.read_u1() if self.has_field_adaptive_dynamic_ray_info: self.adaptive_dynamic_ray_info = Output.ConfigAudioAdaptiveDynamicRayInfo(self._io, self, self._root) @property def has_field_dynamic_ray_info(self): if hasattr(self, '_m_has_field_dynamic_ray_info'): return self._m_has_field_dynamic_ray_info self._m_has_field_dynamic_ray_info = (self.bit_field.value & 16) != 0 return getattr(self, '_m_has_field_dynamic_ray_info', None) @property def has_field_relative_positions(self): if hasattr(self, '_m_has_field_relative_positions'): return self._m_has_field_relative_positions self._m_has_field_relative_positions = (self.bit_field.value & 2) != 0 return getattr(self, '_m_has_field_relative_positions', None) @property def has_field_height_rtpc_key(self): if hasattr(self, '_m_has_field_height_rtpc_key'): return self._m_has_field_height_rtpc_key self._m_has_field_height_rtpc_key = (self.bit_field.value & 64) != 0 return getattr(self, '_m_has_field_height_rtpc_key', None) @property def has_field_tree_info(self): if hasattr(self, '_m_has_field_tree_info'): return self._m_has_field_tree_info self._m_has_field_tree_info = (self.bit_field.value & 8) != 0 return getattr(self, '_m_has_field_tree_info', None) @property def has_field_using_adaptive_openness_detection(self): if hasattr(self, '_m_has_field_using_adaptive_openness_detection'): return self._m_has_field_using_adaptive_openness_detection self._m_has_field_using_adaptive_openness_detection = (self.bit_field.value & 128) != 0 return getattr(self, '_m_has_field_using_adaptive_openness_detection', None) @property def has_field_adaptive_dynamic_ray_info(self): if hasattr(self, '_m_has_field_adaptive_dynamic_ray_info'): return self._m_has_field_adaptive_dynamic_ray_info self._m_has_field_adaptive_dynamic_ray_info = (self.bit_field.value & 256) != 0 return getattr(self, '_m_has_field_adaptive_dynamic_ray_info', None) @property def has_field_positioned_events(self): if hasattr(self, '_m_has_field_positioned_events'): return self._m_has_field_positioned_events self._m_has_field_positioned_events = (self.bit_field.value & 4) != 0 return getattr(self, '_m_has_field_positioned_events', None) @property def has_field_area2d_info(self): if hasattr(self, '_m_has_field_area2d_info'): return self._m_has_field_area2d_info self._m_has_field_area2d_info = (self.bit_field.value & 32) != 0 return getattr(self, '_m_has_field_area2d_info', None) @property def has_field_effective_scene_ids(self): if hasattr(self, '_m_has_field_effective_scene_ids'): return self._m_has_field_effective_scene_ids self._m_has_field_effective_scene_ids = (self.bit_field.value & 1) != 0 return getattr(self, '_m_has_field_effective_scene_ids', None) class MarkTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class SetPaimonLookAtAvatar(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_from_: self.from_ = Output.EnumPaimonRequestFrom(self._io, self, self._root) if self.has_field_lookat: self.lookat = self._io.read_u1() if self.has_field_min_time: self.min_time = self._io.read_f4le() if self.has_field_max_time: self.max_time = self._io.read_f4le() @property def has_field_min_time(self): if hasattr(self, '_m_has_field_min_time'): return self._m_has_field_min_time self._m_has_field_min_time = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_min_time', None) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_max_time(self): if hasattr(self, '_m_has_field_max_time'): return self._m_has_field_max_time self._m_has_field_max_time = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_max_time', None) @property def has_field_lookat(self): if hasattr(self, '_m_has_field_lookat'): return self._m_has_field_lookat self._m_has_field_lookat = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_lookat', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_from_(self): if hasattr(self, '_m_has_field_from_'): return self._m_has_field_from_ self._m_has_field_from_ = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_from_', None) class EnumPushTipsCodexType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PushTipsCodexType, self.data.value) return getattr(self, '_m_value', None) class RewardItemConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_item_id: self.item_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_item_count: self.item_count = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_item_id(self): if hasattr(self, '_m_has_field_item_id'): return self._m_has_field_item_id self._m_has_field_item_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_item_id', None) @property def has_field_item_count(self): if hasattr(self, '_m_has_field_item_count'): return self._m_has_field_item_count self._m_has_field_item_count = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_item_count', None) class WorldLevelExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_level: self.level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_level(self): if hasattr(self, '_m_has_field_level'): return self._m_has_field_level self._m_has_field_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_level', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_monster_level', None) class MonsterCurveExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ContextConditionMainQuestVisible(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ContextCondition(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_main_quest_id: self.main_quest_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_visible: self.visible = self._io.read_u1() @property def has_field_main_quest_id(self): if hasattr(self, '_m_has_field_main_quest_id'): return self._m_has_field_main_quest_id self._m_has_field_main_quest_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_main_quest_id', None) @property def has_field_visible(self): if hasattr(self, '_m_has_field_visible'): return self._m_has_field_visible self._m_has_field_visible = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_visible', None) class KvpOfDictAuxTypesStringF4(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = AuxTypes.String(self._io, self, self._root) self.value = self._io.read_f4le() class EnumFollowTarget(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.FollowTarget, self.data.value) return getattr(self, '_m_value', None) class ArrayOfConfigGadgetUiItemGroupShowCondLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigGadgetUiItemGroupShowCond(self._io, self, self._root)) class RemoveUniqueModifier(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_modifier_name', None) class HideGadgetBubble(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class AnimalCodexSubTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class MultiBadmintonBullet(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_bullet_id: self.bullet_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_weight: self.weight = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_speed: self.speed = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def has_field_bullet_id(self): if hasattr(self, '_m_has_field_bullet_id'): return self._m_has_field_bullet_id self._m_has_field_bullet_id = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_bullet_id', None) @property def has_field_weight(self): if hasattr(self, '_m_has_field_weight'): return self._m_has_field_weight self._m_has_field_weight = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_weight', None) @property def has_field_speed(self): if hasattr(self, '_m_has_field_speed'): return self._m_has_field_speed self._m_has_field_speed = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_speed', None) class ActivityGearGadgetShaftExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ActivityPotionStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableMonsterMoveOnWater(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_enable: self.enable = self._io.read_u1() @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_enable(self): if hasattr(self, '_m_has_field_enable'): return self._m_has_field_enable self._m_has_field_enable = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_enable', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ArrayOfConfigMusicGameKeyLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigMusicGameKey(self._io, self, self._root)) class KvpOfDictEnumInputEventTypeArrayOfAuxTypesStringLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumInputEventType(self._io, self, self._root) self.value = Output.ArrayOfAuxTypesStringLengthU(self._io, self, self._root) class OnLevelTagChangeMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_actions: self.actions = Output.ArrayOfDispConfigAbilityActionLengthU(self._io, self, self._root) @property def has_field_actions(self): if hasattr(self, '_m_has_field_actions'): return self._m_has_field_actions self._m_has_field_actions = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_actions', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumCommonPlayerTipsType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.CommonPlayerTipsType, self.data.value) return getattr(self, '_m_value', None) class EffigyDifficultyExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_challenge_id: self.challenge_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_base_score: self.base_score = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_monster_difficulty: self.monster_difficulty = Output.EnumEffigyDifficulty(self._io, self, self._root) if self.has_field_monster_level: self.monster_level = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_score_ratio: self.score_ratio = self._io.read_f4le() if self.has_field_finish_challenge_index: self.finish_challenge_index = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_monster_difficulty(self): if hasattr(self, '_m_has_field_monster_difficulty'): return self._m_has_field_monster_difficulty self._m_has_field_monster_difficulty = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_monster_difficulty', None) @property def has_field_base_score(self): if hasattr(self, '_m_has_field_base_score'): return self._m_has_field_base_score self._m_has_field_base_score = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_base_score', None) @property def has_field_monster_level(self): if hasattr(self, '_m_has_field_monster_level'): return self._m_has_field_monster_level self._m_has_field_monster_level = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_monster_level', None) @property def has_field_finish_challenge_index(self): if hasattr(self, '_m_has_field_finish_challenge_index'): return self._m_has_field_finish_challenge_index self._m_has_field_finish_challenge_index = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_finish_challenge_index', None) @property def has_field_score_ratio(self): if hasattr(self, '_m_has_field_score_ratio'): return self._m_has_field_score_ratio self._m_has_field_score_ratio = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_score_ratio', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_challenge_id(self): if hasattr(self, '_m_has_field_challenge_id'): return self._m_has_field_challenge_id self._m_has_field_challenge_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_challenge_id', None) class MichiaeStageExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringConfigPerfBoolItemOptionArrayInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfBoolItemOptionArrayInfo(self._io, self, self._root)) class BuffExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_name: self.name = AuxTypes.String(self._io, self, self._root) if self.has_field_desc: self.desc = AuxTypes.String(self._io, self, self._root) if self.has_field_time: self.time = self._io.read_f4le() if self.has_field_stack_type: self.stack_type = Output.EnumBuffStackType(self._io, self, self._root) if self.has_field_is_persistent: self.is_persistent = self._io.read_u1() if self.has_field_is_del_when_leave_scene: self.is_del_when_leave_scene = self._io.read_u1() if self.has_field_server_buff_id: self.server_buff_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_server_buff_type: self.server_buff_type = Output.EnumServerBuffType(self._io, self, self._root) if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) if self.has_field_modifier_name: self.modifier_name = AuxTypes.String(self._io, self, self._root) @property def has_field_server_buff_id(self): if hasattr(self, '_m_has_field_server_buff_id'): return self._m_has_field_server_buff_id self._m_has_field_server_buff_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_server_buff_id', None) @property def has_field_name(self): if hasattr(self, '_m_has_field_name'): return self._m_has_field_name self._m_has_field_name = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_name', None) @property def has_field_server_buff_type(self): if hasattr(self, '_m_has_field_server_buff_type'): return self._m_has_field_server_buff_type self._m_has_field_server_buff_type = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_server_buff_type', None) @property def has_field_desc(self): if hasattr(self, '_m_has_field_desc'): return self._m_has_field_desc self._m_has_field_desc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_desc', None) @property def has_field_is_del_when_leave_scene(self): if hasattr(self, '_m_has_field_is_del_when_leave_scene'): return self._m_has_field_is_del_when_leave_scene self._m_has_field_is_del_when_leave_scene = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_is_del_when_leave_scene', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_is_persistent(self): if hasattr(self, '_m_has_field_is_persistent'): return self._m_has_field_is_persistent self._m_has_field_is_persistent = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_is_persistent', None) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_ability_name', None) @property def has_field_stack_type(self): if hasattr(self, '_m_has_field_stack_type'): return self._m_has_field_stack_type self._m_has_field_stack_type = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_stack_type', None) @property def has_field_modifier_name(self): if hasattr(self, '_m_has_field_modifier_name'): return self._m_has_field_modifier_name self._m_has_field_modifier_name = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_modifier_name', None) @property def has_field_time(self): if hasattr(self, '_m_has_field_time'): return self._m_has_field_time self._m_has_field_time = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_time', None) class EnumWidgetOccupyTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.WidgetOccupyTag, self.data.value) return getattr(self, '_m_value', None) class DictOfAuxTypesStringConfigPerfGradeItemOverrideInfo(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigPerfGradeItemOverrideInfo(self._io, self, self._root)) class RogueDiaryCardWeightExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class AddAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigTalentMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_ability_name: self.ability_name = AuxTypes.String(self._io, self, self._root) @property def has_field_ability_name(self): if hasattr(self, '_m_has_field_ability_name'): return self._m_has_field_ability_name self._m_has_field_ability_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_ability_name', None) class ArrayOfConfigCodexQuestDialogSingleLengthU(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.data = [] for i in range(self.length.value): self.data.append(Output.ConfigCodexQuestDialogSingle(self._io, self, self._root)) class EnumPileTag(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.PileTag, self.data.value) return getattr(self, '_m_value', None) class GroupLinksBundleRewardExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_reward_id: self.reward_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_reward_preview_id: self.reward_preview_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_drop_id: self.drop_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) @property def has_field_reward_id(self): if hasattr(self, '_m_has_field_reward_id'): return self._m_has_field_reward_id self._m_has_field_reward_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_reward_id', None) @property def has_field_reward_preview_id(self): if hasattr(self, '_m_has_field_reward_preview_id'): return self._m_has_field_reward_preview_id self._m_has_field_reward_preview_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_reward_preview_id', None) @property def has_field_drop_id(self): if hasattr(self, '_m_has_field_drop_id'): return self._m_has_field_drop_id self._m_has_field_drop_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_drop_id', None) class MechanicusCardTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class FaceAnimationItem(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ConfigActivityBanner(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_condition_defines: self.condition_defines = Output.DictOfAuxTypesStringDispContextCondition(self._io, self, self._root) if self.has_field_action_defines: self.action_defines = Output.DictOfAuxTypesStringDispContextAction(self._io, self, self._root) if self.has_field_update_groups: self.update_groups = Output.ArrayOfContextConditionActionGroupLengthU(self._io, self, self._root) if self.has_field_click_groups: self.click_groups = Output.ArrayOfContextConditionActionGroupLengthU(self._io, self, self._root) @property def has_field_condition_defines(self): if hasattr(self, '_m_has_field_condition_defines'): return self._m_has_field_condition_defines self._m_has_field_condition_defines = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_condition_defines', None) @property def has_field_action_defines(self): if hasattr(self, '_m_has_field_action_defines'): return self._m_has_field_action_defines self._m_has_field_action_defines = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_action_defines', None) @property def has_field_update_groups(self): if hasattr(self, '_m_has_field_update_groups'): return self._m_has_field_update_groups self._m_has_field_update_groups = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_update_groups', None) @property def has_field_click_groups(self): if hasattr(self, '_m_has_field_click_groups'): return self._m_has_field_click_groups self._m_has_field_click_groups = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_click_groups', None) class ConfigEmotionInterAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigBaseInterAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_emotion_name: self.emotion_name = AuxTypes.String(self._io, self, self._root) if self.has_field_emotion_transition_time: self.emotion_transition_time = self._io.read_f4le() if self.has_field_look_at_offset: self.look_at_offset = Output.Vector(self._io, self, self._root) if self.has_field_blink_enabled: self.blink_enabled = self._io.read_u1() if self.has_field_blink_min_gap: self.blink_min_gap = self._io.read_f4le() if self.has_field_blink_max_gap: self.blink_max_gap = self._io.read_f4le() if self.has_field_blink_duration: self.blink_duration = self._io.read_f4le() @property def has_field_blink_max_gap(self): if hasattr(self, '_m_has_field_blink_max_gap'): return self._m_has_field_blink_max_gap self._m_has_field_blink_max_gap = (self.bit_field & 32) != 0 return getattr(self, '_m_has_field_blink_max_gap', None) @property def action_id(self): if hasattr(self, '_m_action_id'): return self._m_action_id self._m_action_id = self.base.action_id return getattr(self, '_m_action_id', None) @property def alias_list(self): if hasattr(self, '_m_alias_list'): return self._m_alias_list self._m_alias_list = self.base.alias_list return getattr(self, '_m_alias_list', None) @property def has_field_look_at_offset(self): if hasattr(self, '_m_has_field_look_at_offset'): return self._m_has_field_look_at_offset self._m_has_field_look_at_offset = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_look_at_offset', None) @property def has_field_emotion_name(self): if hasattr(self, '_m_has_field_emotion_name'): return self._m_has_field_emotion_name self._m_has_field_emotion_name = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_emotion_name', None) @property def has_field_blink_min_gap(self): if hasattr(self, '_m_has_field_blink_min_gap'): return self._m_has_field_blink_min_gap self._m_has_field_blink_min_gap = (self.bit_field & 16) != 0 return getattr(self, '_m_has_field_blink_min_gap', None) @property def check_next_immediately(self): if hasattr(self, '_m_check_next_immediately'): return self._m_check_next_immediately self._m_check_next_immediately = self.base.check_next_immediately return getattr(self, '_m_check_next_immediately', None) @property def delay_time(self): if hasattr(self, '_m_delay_time'): return self._m_delay_time self._m_delay_time = self.base.delay_time return getattr(self, '_m_delay_time', None) @property def has_field_blink_duration(self): if hasattr(self, '_m_has_field_blink_duration'): return self._m_has_field_blink_duration self._m_has_field_blink_duration = (self.bit_field & 64) != 0 return getattr(self, '_m_has_field_blink_duration', None) @property def duration(self): if hasattr(self, '_m_duration'): return self._m_duration self._m_duration = self.base.duration return getattr(self, '_m_duration', None) @property def have_next_action(self): if hasattr(self, '_m_have_next_action'): return self._m_have_next_action self._m_have_next_action = self.base.have_next_action return getattr(self, '_m_have_next_action', None) @property def has_field_emotion_transition_time(self): if hasattr(self, '_m_has_field_emotion_transition_time'): return self._m_has_field_emotion_transition_time self._m_has_field_emotion_transition_time = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_emotion_transition_time', None) @property def has_field_blink_enabled(self): if hasattr(self, '_m_has_field_blink_enabled'): return self._m_has_field_blink_enabled self._m_has_field_blink_enabled = (self.bit_field & 8) != 0 return getattr(self, '_m_has_field_blink_enabled', None) @property def type(self): if hasattr(self, '_m_type'): return self._m_type self._m_type = self.base.type return getattr(self, '_m_type', None) @property def pre_action_id(self): if hasattr(self, '_m_pre_action_id'): return self._m_pre_action_id self._m_pre_action_id = self.base.pre_action_id return getattr(self, '_m_pre_action_id', None) class KvpOfDictEnumTextMapPlatformTypeAuxTypesVlqBase128LeS(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.key = Output.EnumTextMapPlatformType(self._io, self, self._root) self.value = AuxTypes.VlqBase128LeS(self._io, self, self._root) class SectrObjectTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class ByTargetInArea(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityPredicate(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_area_level: self.area_level = Output.EnumTargetPositionAreaLevel(self._io, self, self._root) if self.has_field_areas: self.areas = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_area_level(self): if hasattr(self, '_m_has_field_area_level'): return self._m_has_field_area_level self._m_has_field_area_level = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_area_level', None) @property def has_field_areas(self): if hasattr(self, '_m_has_field_areas'): return self._m_has_field_areas self._m_has_field_areas = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_areas', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) class DictOfEnumMarkIconTypeConfigMarkIcon(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumMarkIconTypeConfigMarkIcon(self._io, self, self._root)) class EnumGuideCameraAction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.GuideCameraAction, self.data.value) return getattr(self, '_m_value', None) class LevelDayTimeTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DispConfigAbility(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.type_code = AuxTypes.VlqBase128LeU(self._io, self, self._root) _on = self.type_code.value if _on == 0: self.data = Output.ConfigAbility(self._io, self, self._root) elif _on == 1: self.data = Output.ConfigDummyAbility(self._io, self, self._root) else: self.data = AuxTypes.Error(self._io, self, self._root) class ActivityPhotographExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_activity_id: self.activity_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_photo_pos_id_list: self.photo_pos_id_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_photo_useable_widget_list: self.photo_useable_widget_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_activity_id(self): if hasattr(self, '_m_has_field_activity_id'): return self._m_has_field_activity_id self._m_has_field_activity_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_activity_id', None) @property def has_field_photo_pos_id_list(self): if hasattr(self, '_m_has_field_photo_pos_id_list'): return self._m_has_field_photo_pos_id_list self._m_has_field_photo_pos_id_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_photo_pos_id_list', None) @property def has_field_photo_useable_widget_list(self): if hasattr(self, '_m_has_field_photo_useable_widget_list'): return self._m_has_field_photo_useable_widget_list self._m_has_field_photo_useable_widget_list = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_photo_useable_widget_list', None) class FireFishingEvent(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_event_type: self.event_type = Output.EnumFishingEvent(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def has_field_event_type(self): if hasattr(self, '_m_has_field_event_type'): return self._m_has_field_event_type self._m_has_field_event_type = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_event_type', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class ConfigCrowdTimeRestriction(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = self._io.read_u1() if self.has_field_start_time_of_day: self.start_time_of_day = self._io.read_f4le() if self.has_field_end_time_of_day: self.end_time_of_day = self._io.read_f4le() if self.has_field_show_crowd: self.show_crowd = self._io.read_u1() @property def has_field_start_time_of_day(self): if hasattr(self, '_m_has_field_start_time_of_day'): return self._m_has_field_start_time_of_day self._m_has_field_start_time_of_day = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_start_time_of_day', None) @property def has_field_end_time_of_day(self): if hasattr(self, '_m_has_field_end_time_of_day'): return self._m_has_field_end_time_of_day self._m_has_field_end_time_of_day = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_end_time_of_day', None) @property def has_field_show_crowd(self): if hasattr(self, '_m_has_field_show_crowd'): return self._m_has_field_show_crowd self._m_has_field_show_crowd = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_show_crowd', None) class DictOfAuxTypesStringConfigAiSkill(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringConfigAiSkill(self._io, self, self._root)) class EnumChestShowMoment(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.ChestShowMoment, self.data.value) return getattr(self, '_m_value', None) class FireworksReformSkillTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class PersistentFurnitureTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class BattlePassLevelExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnumInputActionType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.InputActionType, self.data.value) return getattr(self, '_m_value', None) class HomeWorldEventExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfEnumJsonClimateTypeAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictEnumJsonClimateTypeAuxTypesString(self._io, self, self._root)) class EnumSubChallengeFadeOutType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.SubChallengeFadeOutType, self.data.value) return getattr(self, '_m_value', None) class RegistToStageScript(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityAction(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_alias: self.alias = AuxTypes.String(self._io, self, self._root) @property def do_off_stage(self): if hasattr(self, '_m_do_off_stage'): return self._m_do_off_stage self._m_do_off_stage = self.base.do_off_stage return getattr(self, '_m_do_off_stage', None) @property def target(self): if hasattr(self, '_m_target'): return self._m_target self._m_target = self.base.target return getattr(self, '_m_target', None) @property def predicates(self): if hasattr(self, '_m_predicates'): return self._m_predicates self._m_predicates = self.base.predicates return getattr(self, '_m_predicates', None) @property def do_after_die(self): if hasattr(self, '_m_do_after_die'): return self._m_do_after_die self._m_do_after_die = self.base.do_after_die return getattr(self, '_m_do_after_die', None) @property def token(self): if hasattr(self, '_m_token'): return self._m_token self._m_token = self.base.token return getattr(self, '_m_token', None) @property def other_targets(self): if hasattr(self, '_m_other_targets'): return self._m_other_targets self._m_other_targets = self.base.other_targets return getattr(self, '_m_other_targets', None) @property def can_be_handled_on_recover(self): if hasattr(self, '_m_can_be_handled_on_recover'): return self._m_can_be_handled_on_recover self._m_can_be_handled_on_recover = self.base.can_be_handled_on_recover return getattr(self, '_m_can_be_handled_on_recover', None) @property def predicates_foreach(self): if hasattr(self, '_m_predicates_foreach'): return self._m_predicates_foreach self._m_predicates_foreach = self.base.predicates_foreach return getattr(self, '_m_predicates_foreach', None) @property def has_field_alias(self): if hasattr(self, '_m_has_field_alias'): return self._m_has_field_alias self._m_has_field_alias = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_alias', None) @property def mute_remote_action(self): if hasattr(self, '_m_mute_remote_action'): return self._m_mute_remote_action self._m_mute_remote_action = self.base.mute_remote_action return getattr(self, '_m_mute_remote_action', None) class DvalinS01pathEffsMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) self.bit_field = self._io.read_u1() if self.has_field_effect_start: self.effect_start = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_effect_end: self.effect_end = AuxTypes.VlqBase128LeS(self._io, self, self._root) if self.has_field_eff_infos: self.eff_infos = Output.ArrayOfDvalinS01pathEffsInfoLengthU(self._io, self, self._root) @property def has_field_effect_start(self): if hasattr(self, '_m_has_field_effect_start'): return self._m_has_field_effect_start self._m_has_field_effect_start = (self.bit_field & 1) != 0 return getattr(self, '_m_has_field_effect_start', None) @property def has_field_effect_end(self): if hasattr(self, '_m_has_field_effect_end'): return self._m_has_field_effect_end self._m_has_field_effect_end = (self.bit_field & 2) != 0 return getattr(self, '_m_has_field_effect_end', None) @property def has_field_eff_infos(self): if hasattr(self, '_m_has_field_eff_infos'): return self._m_has_field_eff_infos self._m_has_field_eff_infos = (self.bit_field & 4) != 0 return getattr(self, '_m_has_field_eff_infos', None) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class EnumUgcFormulaType(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.data = AuxTypes.VlqBase128LeS(self._io, self, self._root) @property def value(self): if hasattr(self, '_m_value'): return self._m_value self._m_value = KaitaiStream.resolve_enum(Output.UgcFormulaType, self.data.value) return getattr(self, '_m_value', None) class FetterCharacterCardExcelConfigLoader(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class DictOfAuxTypesStringAuxTypesString(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.length = AuxTypes.VlqBase128LeU(self._io, self, self._root) self.items = [] for i in range(self.length.value): self.items.append(Output.KvpOfDictAuxTypesStringAuxTypesString(self._io, self, self._root)) class FleurFairMiniGameTypeComparer(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): pass class EnableCharacterMoveOnWaterMixin(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.base = Output.ConfigAbilityMixin(self._io, self, self._root) @property def is_unique(self): if hasattr(self, '_m_is_unique'): return self._m_is_unique self._m_is_unique = self.base.is_unique return getattr(self, '_m_is_unique', None) class HideAndSeekMatchExcelConfig(KaitaiStruct): def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._read() def _read(self): self.bit_field = AuxTypes.LengthPrefixedBitfield(self._io, self, self._root) if self.has_field_title: self.title = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_tips: self.unlock_tips = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_tips2: self.unlock_tips2 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_unlock_tips3: self.unlock_tips3 = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_dsc: self.dsc = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_icon_path_hash: self.map_icon_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_icon_path_hash: self.map_icon_path_hash_pre = self._io.read_s1() if self.has_field_map_small_icon_path_hash: self.map_small_icon_path_hash_suffix = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_map_small_icon_path_hash: self.map_small_icon_path_hash_pre = self._io.read_s1() if self.has_field_scene_id: self.scene_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_group_id: self.group_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_transport_point_list: self.transport_point_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_duration_list: self.duration_list = Output.ArrayOfAuxTypesVlqBase128LeULengthU(self._io, self, self._root) if self.has_field_gallery_id: self.gallery_id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_id: self.id = AuxTypes.VlqBase128LeU(self._io, self, self._root) if self.has_field_cond: self.cond = Output.ArrayOfMatchCondLengthS(self._io, self, self._root) @property def has_field_transport_point_list(self): if hasattr(self, '_m_has_field_transport_point_list'): return self._m_has_field_transport_point_list self._m_has_field_transport_point_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 2) != 0)) return getattr(self, '_m_has_field_transport_point_list', None) @property def has_field_title(self): if hasattr(self, '_m_has_field_title'): return self._m_has_field_title self._m_has_field_title = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 1) != 0)) return getattr(self, '_m_has_field_title', None) @property def has_field_map_icon_path_hash(self): if hasattr(self, '_m_has_field_map_icon_path_hash'): return self._m_has_field_map_icon_path_hash self._m_has_field_map_icon_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 32) != 0)) return getattr(self, '_m_has_field_map_icon_path_hash', None) @property def has_field_cond(self): if hasattr(self, '_m_has_field_cond'): return self._m_has_field_cond self._m_has_field_cond = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 32) != 0)) return getattr(self, '_m_has_field_cond', None) @property def has_field_scene_id(self): if hasattr(self, '_m_has_field_scene_id'): return self._m_has_field_scene_id self._m_has_field_scene_id = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 128) != 0)) return getattr(self, '_m_has_field_scene_id', None) @property def has_field_dsc(self): if hasattr(self, '_m_has_field_dsc'): return self._m_has_field_dsc self._m_has_field_dsc = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 16) != 0)) return getattr(self, '_m_has_field_dsc', None) @property def has_field_gallery_id(self): if hasattr(self, '_m_has_field_gallery_id'): return self._m_has_field_gallery_id self._m_has_field_gallery_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 8) != 0)) return getattr(self, '_m_has_field_gallery_id', None) @property def has_field_group_id(self): if hasattr(self, '_m_has_field_group_id'): return self._m_has_field_group_id self._m_has_field_group_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 1) != 0)) return getattr(self, '_m_has_field_group_id', None) @property def has_field_unlock_tips2(self): if hasattr(self, '_m_has_field_unlock_tips2'): return self._m_has_field_unlock_tips2 self._m_has_field_unlock_tips2 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 4) != 0)) return getattr(self, '_m_has_field_unlock_tips2', None) @property def has_field_unlock_tips3(self): if hasattr(self, '_m_has_field_unlock_tips3'): return self._m_has_field_unlock_tips3 self._m_has_field_unlock_tips3 = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 8) != 0)) return getattr(self, '_m_has_field_unlock_tips3', None) @property def has_field_map_small_icon_path_hash(self): if hasattr(self, '_m_has_field_map_small_icon_path_hash'): return self._m_has_field_map_small_icon_path_hash self._m_has_field_map_small_icon_path_hash = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 64) != 0)) return getattr(self, '_m_has_field_map_small_icon_path_hash', None) @property def has_field_id(self): if hasattr(self, '_m_has_field_id'): return self._m_has_field_id self._m_has_field_id = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 16) != 0)) return getattr(self, '_m_has_field_id', None) @property def has_field_duration_list(self): if hasattr(self, '_m_has_field_duration_list'): return self._m_has_field_duration_list self._m_has_field_duration_list = ((self.bit_field.length.value >= (1 + 1)) and ((self.bit_field.bitfield[1] & 4) != 0)) return getattr(self, '_m_has_field_duration_list', None) @property def has_field_unlock_tips(self): if hasattr(self, '_m_has_field_unlock_tips'): return self._m_has_field_unlock_tips self._m_has_field_unlock_tips = ((self.bit_field.length.value >= (0 + 1)) and ((self.bit_field.bitfield[0] & 2) != 0)) return getattr(self, '_m_has_field_unlock_tips', None)